Java多线程通信问题深入了解

概述

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

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

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

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

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

引入

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

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

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

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

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

• 定义厨师线程

 /** * 厨师，是一个线程 */ static class Cook extends Thread{ private Food f; public Cook(Food f){ this.f = f; } //运行的线程，生成100道菜 @Override public void run() { for (int i = 0 ; i <100; i ++){ if(i % 2 == 0){ f.setNameAneTaste("小米粥","没味道，不好吃"); }else{ f.setNameAneTaste("老北京鸡肉卷","甜辣味"); } } } } 

• 定义服务员线程

 /** * 服务员，是一个线程 */ static class Waiter extends Thread{ private Food f; public Waiter(Food f){ this.f = f; } @Override public void run() { for(int i =0 ; i <100;i ++){ //等待 try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } f.get(); } }//end run }//end waiter 

• 新建食物类

 /** * 食物，对象 */ static class Food{ private String name; private String taste; public void setNameAneTaste(String name,String taste){ this.name = name; //加了这段之后，有可能这个地方的时间片更有可能被抢走，从而执行不了this.taste = taste try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } this.taste = taste; }//end set public void get(){ System.out.println("服务员端走的菜的名称是：" + this.name + " 味道：" + this.taste); } }//end food 

main方法中去调用两个线程

 public static void main(String[] args) { Food f = new Food(); Cook c = new Cook(f); Waiter w = new Waiter(f); c.start();//厨师线程 w.start();//服务生线程 } 

运行结果：

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

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

name和taste对应错乱的原因：

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

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

以上运行结果解释如图：

加入线程安全

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

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

 /** * 食物，对象 */ static class Food{ private String name; private String taste; public synchronized void setNameAneTaste(String name,String taste){ this.name = name; try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } this.taste = taste; }//end set public synchronized void get(){ System.out.println("服务员端走的菜的名称是：" + this.name + " 味道：" + this.taste); } }//end food 

输出结果：

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

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

以上就是Java多线程通信问题深入了解的详细内容，更多请关注0133技术站其它相关文章！