Java中怎么实现多线程通信

Java中怎么实现多线程通信，相信很多没有经验的人对此束手无策，为此本文总结了问题出现的原因和解决方法，通过这篇文章希望你能解决这个问题。

概述

多线程通信问题，也就是生产者与消费者问题

生产者和消费者为两个线程，两个线程在运行过程中交替睡眠，生产者在生产时消费者没有在消费，消费者在消费时生产者没有在生产，确保数据安全

以下为百度百科对于该问题的解释：

生产者与消费者问题：生产者消费者问题（Producer-consumer problem），也称有限缓冲问题（Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。

解决办法：要解决该问题，就必须让生产者在缓冲区满时休眠（要么干脆就放弃数据），等到下次消费者消耗缓冲区中的数据的时候，生产者才能被唤醒，开始往缓冲区添加数据。同样，也可以让消费者在缓冲区空时进入休眠，等到生产者往缓冲区添加数据之后，再唤醒消费者。通常采用进程间通信的方法解决该问题，常用的方法有信号灯法等。如果解决方法不够完善，则容易出现死锁的情况。出现死锁时，两个线程都会陷入休眠，等待对方唤醒自己。该问题也能被推广到多个生产者和消费者的情形。

引入

该过程可以类比为一个栗子：

厨师为生产者，服务员为消费者，假设只有一个盘子盛放食品。

厨师在生产食品（厨师线程运行）的过程中，服务员应当等待（服务员线程睡眠），等到食品生产完成（厨师线程结束）后将食品放入盘子中，服务员将盘子端出去（服务员线程运行），此时没有盘子可以放食品，因此厨师休息（厨师线程休眠），一段时间过后服务员将盘子拿回来（服务员线程结束），厨师开始进行生产食品（厨师线程运行），服务员在一旁等待（服务员线程睡眠）…

在此过程中，厨师和服务员两个线程交替睡眠，厨师在做饭时服务员没有端盘子（厨师线程运行时服务员线程睡眠），服务员在端盘子时厨师没有在做饭（服务员线程运行时厨师线程睡眠），确保了数据的安全

根据厨师和服务员这个栗子，我们可以通过代码来一步步实现

• 定义厨师线程

/**
*厨师，是一个线程
*/
staticclassCookextendsThread{
privateFoodf;
publicCook(Foodf){
this.f=f;
}
//运行的线程，生成100道菜
@Override
publicvoidrun(){
for(inti=0;i<100;i++){
if(i%2==0){
f.setNameAneTaste("小米粥","没味道，不好吃");
}else{
f.setNameAneTaste("老北京鸡肉卷","甜辣味");
}
}
}
}

• 定义服务员线程

/**
*服务员，是一个线程
*/
staticclassWaiterextendsThread{
privateFoodf;
publicWaiter(Foodf){
this.f=f;
}
@Override
publicvoidrun(){
for(inti=0;i<100;i++){
//等待
try{
Thread.sleep(100);
}catch(InterruptedExceptione){
e.printStackTrace();
}
f.get();
}
}//endrun
}//endwaiter

• 新建食物类

/**
*食物，对象
*/
staticclassFood{
privateStringname;
privateStringtaste;
publicvoidsetNameAneTaste(Stringname,Stringtaste){
this.name=name;
//加了这段之后，有可能这个地方的时间片更有可能被抢走，从而执行不了this.taste=taste
try{
Thread.sleep(100);
}catch(InterruptedExceptione){
e.printStackTrace();
}
this.taste=taste;
}//endset
publicvoidget(){
System.out.println("服务员端走的菜的名称是："+this.name+"味道："+this.taste);
}
}//endfood

main方法中去调用两个线程

publicstaticvoidmain(String[]args){
Foodf=newFood();
Cookc=newCook(f);
Waiterw=newWaiter(f);
c.start();//厨师线程
w.start();//服务生线程
}

运行结果：

只截取了一部分，我们可以看到，“小米粥”并没有每次都对应“没味道，不好吃”，“老北京鸡肉卷”也没有每次都对应“甜辣味”，而是一种错乱的对应关系

...服务员端走的菜的名称是：老北京鸡肉卷 味道：没味道，不好吃服务员端走的菜的名称是：小米粥 味道：甜辣味服务员端走的菜的名称是：老北京鸡肉卷 味道：没味道，不好吃服务员端走的菜的名称是：小米粥 味道：甜辣味服务员端走的菜的名称是：老北京鸡肉卷 味道：没味道，不好吃服务员端走的菜的名称是：小米粥 味道：甜辣味服务员端走的菜的名称是：老北京鸡肉卷 味道：没味道，不好吃服务员端走的菜的名称是：小米粥 味道：甜辣味服务员端走的菜的名称是：老北京鸡肉卷 味道：没味道，不好吃服务员端走的菜的名称是：老北京鸡肉卷 味道：甜辣味...

name和taste对应错乱的原因：

当厨师调用set方法时，刚设置完name，程序进行了休眠，此时服务员可能已经将食品端走了，而此时的taste是上一次运行时保留的taste。

两个线程一起运行时，由于使用抢占式调度模式，没有协调，因此出现了该现象

以上运行结果解释如图：

加入线程安全

针对上面的线程不安全问题，对厨师set和服务员get这两个线程都使用synchronized关键字，实现线程安全，即：当一个线程正在执行时，另外的线程不会执行，在后面排队等待当前的程序执行完后再执行

代码如下所示，分别给两个方法添加synchronized修饰符，以方法为单位进行加锁，实现线程安全

	/**
*食物，对象
*/
staticclassFood{
privateStringname;
privateStringtaste;
publicsynchronizedvoidsetNameAneTaste(Stringname,Stringtaste){
this.name=name;
try{
Thread.sleep(100);
}catch(InterruptedExceptione){
e.printStackTrace();
}
this.taste=taste;
}//endset
publicsynchronizedvoidget(){
System.out.println("服务员端走的菜的名称是："+this.name+"味道："+this.taste);
}
}//endfood

输出结果：

由输出可见，又出现了新的问题：虽然加入了线程安全，set和get方法不再像前面一样同时执行并且菜名和味道一一对应，但是set和get方法并没有交替执行（通俗地讲，不是厨师一做完服务员就端走），而是无序地执行（厨师有可能做完之后继续做，做好几道，服务员端好几次…无规律地做和端）

...服务员端走的菜的名称是：小米粥 味道：没味道，不好吃服务员端走的菜的名称是：小米粥 味道：没味道，不好吃服务员端走的菜的名称是：老北京鸡肉卷 味道：甜辣味服务员端走的菜的名称是：小米粥 味道：没味道，不好吃服务员端走的菜的名称是：老北京鸡肉卷 味道：甜辣味服务员端走的菜的名称是：小米粥 味道：没味道，不好吃服务员端走的菜的名称是：老北京鸡肉卷 味道：甜辣味服务员端走的菜的名称是：小米粥 味道：没味道，不好吃服务员端走的菜的名称是：老北京鸡肉卷 味道：甜辣味服务员端走的菜的名称是：小米粥 味道：没味道，不好吃服务员端走的菜的名称是：小米粥 味道：没味道，不好吃服务员端走的菜的名称是：老北京鸡肉卷 味道：甜辣味服务员端走的菜的名称是：老北京鸡肉卷 味道：甜辣味服务员端走的菜的名称是：小米粥 味道：没味道，不好吃服务员端走的菜的名称是：老北京鸡肉卷 味道：甜辣味服务员端走的菜的名称是：老北京鸡肉卷 味道：甜辣味服务员端走的菜的名称是：老北京鸡肉卷 味道：甜辣味服务员端走的菜的名称是：老北京鸡肉卷 味道：甜辣味服务员端走的菜的名称是：老北京鸡肉卷 味道：甜辣味服务员端走的菜的名称是：老北京鸡肉卷 味道：甜辣味...

实现生产者与消费者问题

由上面可知，加入线程安全依旧无法实现该问题。因此，要解决该问题，回到前面的引入部分，严格按照生产者与消费者问题中所说地去编写程序

生产者与消费者问题：生产者和消费者为两个线程，两个线程在运行过程中交替睡眠，生产者在生产时消费者没有在消费，消费者在消费时生产者没有在生产，确保数据安全↓厨师在生产食品（厨师线程运行）的过程中，服务员应当等待（服务员线程睡眠），等到食品生产完成（厨师线程结束）后将食品放入盘子中，服务员将盘子端出去（服务员线程运行），此时没有盘子可以放食品，因此厨师休息（厨师线程休眠），一段时间过后服务员将盘子拿回来（服务员线程结束），厨师开始进行生产食品（厨师线程运行），服务员在一旁等待（服务员线程睡眠）…↓在此过程中，厨师和服务员两个线程交替睡眠，厨师在做饭时服务员没有端盘子（厨师线程运行时服务员线程睡眠），服务员在端盘子时厨师没有在做饭（服务员线程运行时厨师线程睡眠），确保数据的安全

需要用到的java.lang.Object 中的方法：

• 首先在Food类中加一个标记flag：

True表示厨师生产，服务员休眠

False表示服务员端菜，厨师休眠

privatebooleanflag=true;

对set方法进行修改

当且仅当flag为True（True表示厨师生产，服务员休眠）时，才能进行做菜操作

做菜结束时，将flag置为False（False表示服务员端菜，厨师休眠），这样厨师在生产完之后不会继续生产，避免了厨师两次生产、服务员端走一份的情况

然后唤醒在当前this下休眠的所有进程，而厨师线程进行休眠

		publicsynchronizedvoidsetNameAneTaste(Stringname,Stringtaste){
if(flag){//当标记为true时，表示厨师可以生产，该方法才执行
this.name=name;
try{
Thread.sleep(100);
}catch(InterruptedExceptione){
e.printStackTrace();
}
this.taste=taste;
flag=false;//生产完之后，标记置为false，这样厨师在生产完之后不会继续生产，避免了厨师两次生产、服务员端走一份的情况
this.notifyAll();//唤醒在当前this下休眠的所有进程
try{
this.wait();//此时厨师线程进行休眠
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
}//endset

• 对get方法进行修改

当且仅当flag为False（False表示服务员端菜，厨师休眠）时，才能进行端菜操作

端菜结束时，将flag置为True（True表示厨师生产，服务员休眠），这样服务员在端完菜之后不会继续端菜，避免了服务员两次端菜、厨师生产一份的情况

然后唤醒在当前this下休眠的所有进程，而服务员线程进行休眠

publicsynchronizedvoidget(){
if(!flag){//厨师休眠的时候，服务员开始端菜
System.out.println("服务员端走的菜的名称是："+this.name+"味道："+this.taste);
flag=true;//端完之后，标记置为true，这样服务员在端完菜之后不会继续端菜，避免了服务员两次端菜、厨师只生产一份的情况
this.notifyAll();//唤醒在当前this下休眠的所有进程
try{
this.wait();//此时服务员线程进行休眠
}catch(InterruptedExceptione){
e.printStackTrace();
}
}//endif
}//endget

看完上述内容，你们掌握Java中怎么实现多线程通信的方法了吗？如果还想学到更多技能或想了解更多相关内容，欢迎关注恰卡编程网行业资讯频道，感谢各位的阅读！