首页 > 代码库 > 【转】通过生产者消费者案例理解等待唤醒机制和虚假唤醒
【转】通过生产者消费者案例理解等待唤醒机制和虚假唤醒
首先引入下面这段生产者和消费者的程序，店员类作为生产产品和消费产品的中介，其中的数据product为共享数据，产品最多只能囤积5个，当产品达到5个还在生产时，就会提示“产品已满！”，类似地，如果产品只有0个了还在消费，会提示“缺货！”：
1 package concurrent; 2 3 //店员类 4 class Clerk { 5 private int product = 0; 6 7 // 进货 8 public synchronized void get() { 9 if (product >= 5) { 10 System.out.println("产品已满！"); 11 } else { 12 System.out.println(Thread.currentThread().getName() + ":" + ++product); 13 } 14 } 15 16 // 售货 17 public synchronized void sale() { 18 if (product <= 0) { 19 System.out.println("缺货！"); 20 } else { 21 System.out.println(Thread.currentThread().getName() + ":" + --product); 22 } 23 } 24 } 25 26 // 生产者类 27 class Productor implements Runnable { 28 29 private Clerk clerk; 30 31 public Productor(Clerk clerk) { 32 this.clerk = clerk; 33 } 34 35 @Override 36 public void run() { 37 for (int i = 0; i < 10; i++) { 38 clerk.get(); 39 } 40 41 } 42 } 43 44 //消费者类 45 class Consumer implements Runnable { 46 47 private Clerk clerk; 48 49 public Consumer(Clerk clerk) { 50 this.clerk = clerk; 51 } 52 53 @Override 54 public void run() { 55 for (int i = 0; i < 10; i++) { 56 clerk.sale(); 57 } 58 } 59 } 60 61 public class TestProductorAndConsumer { 62 63 public static void main(String[] args) { 64 Clerk clerk = new Clerk(); 65 66 Productor productor = new Productor(clerk); 67 Consumer consumer = new Consumer(clerk); 68 69 new Thread(productor,"Productor A").start(); 70 new Thread(consumer,"Consumer B").start(); 71 } 72 }
运行程序，结果如下：
这是一种不好的情况，因为当产品已满时，还在不停地生产，当缺货时，还在不停地消费。为此，我们引入等待唤醒机制：
1 package concurrent; 2 3 //店员类 4 class Clerk { 5 private int product = 0; 6 7 // 进货 8 public synchronized void get() { 9 if (product >= 5) { 10 System.out.println("产品已满！"); 11 12 //等待 13 try { 14 this.wait(); 15 } catch (InterruptedException e) { 16 e.printStackTrace(); 17 } 18 } else { 19 System.out.println(Thread.currentThread().getName() + ":" + ++product); 20 //唤醒 21 this.notifyAll(); 22 } 23 } 24 25 // 售货 26 public synchronized void sale() { 27 if (product <= 0) { 28 System.out.println("缺货！"); 29 //等待 30 try { 31 this.wait(); 32 } catch (InterruptedException e) { 33 e.printStackTrace(); 34 } 35 } else { 36 System.out.println(Thread.currentThread().getName() + ":" + --product); 37 //唤醒 38 this.notifyAll(); 39 } 40 } 41 } 42 43 // 生产者类 44 class Productor implements Runnable { 45 46 private Clerk clerk; 47 48 public Productor(Clerk clerk) { 49 this.clerk = clerk; 50 } 51 52 @Override 53 public void run() { 54 for (int i = 0; i < 10; i++) { 55 clerk.get(); 56 } 57 } 58 } 59 60 //消费者类 61 class Consumer implements Runnable { 62 63 private Clerk clerk; 64 65 public Consumer(Clerk clerk) { 66 this.clerk = clerk; 67 } 68 69 @Override 70 public void run() { 71 for (int i = 0; i < 10; i++) { 72 clerk.sale(); 73 } 74 75 } 76 } 77 78 public class TestProductorAndConsumer { 79 80 public static void main(String[] args) { 81 Clerk clerk = new Clerk(); 82 83 Productor productor = new Productor(clerk); 84 Consumer consumer = new Consumer(clerk); 85 86 new Thread(productor,"Productor A").start(); 87 new Thread(consumer,"Consumer B").start(); 88 } 89 }
再运行程序，就不会再出现上述的情况：
但是，现在，我们将产品的囤积上限设定为1（这种情况在现实中也是有可能出现的）：
然后运行程序：
程序的输出貌似没有问题，但请注意图中箭头所指的地方，这表示程序没有结束，还一直在执行。这是因为，当循坏到最后一轮时，由于产品已满引发了wait()操作，然后生产者线程等待，随后消费者消费了一份产品，并唤醒等待的生产者线程，此时，被唤醒的生产者线程由于循环结束，直接结束了线程的执行，但是另一边，消费者线程没有结束，而且由于将产品消费完后再次进入了等待，但是生产者线程此时已经结束了，不能再唤醒消费者线程，所以便进入了死循环。
解决这种问题的方法时去掉Clerk类中get方法和sale方法的else，并将原来else中的代码直接提出，这样，就算线程结束，也会先再次唤醒等待的线程：
1 package concurrent; 2 3 //店员类 4 class Clerk { 5 private int product = 0; 6 7 // 进货 8 public synchronized void get() { 9 if (product >= 1) { 10 System.out.println("产品已满！"); 11 12 // 等待 13 try { 14 this.wait(); 15 } catch (InterruptedException e) { 16 e.printStackTrace(); 17 } 18 } 19 System.out.println(Thread.currentThread().getName() + ":" + ++product); 20 // 唤醒 21 this.notifyAll(); 22 } 23 24 // 售货 25 public synchronized void sale() { 26 if (product <= 0) { 27 System.out.println("缺货！"); 28 // 等待 29 try { 30 this.wait(); 31 } catch (InterruptedException e) { 32 e.printStackTrace(); 33 } 34 } 35 System.out.println(Thread.currentThread().getName() + ":" + --product); 36 // 唤醒 37 this.notifyAll(); 38 } 39 } 40 41 // 生产者类 42 class Productor implements Runnable { 43 44 private Clerk clerk; 45 46 public Productor(Clerk clerk) { 47 this.clerk = clerk; 48 } 49 50 @Override 51 public void run() { 52 for (int i = 0; i < 10; i++) { 53 clerk.get(); 54 } 55 } 56 } 57 58 // 消费者类 59 class Consumer implements Runnable { 60 61 private Clerk clerk; 62 63 public Consumer(Clerk clerk) { 64 this.clerk = clerk; 65 } 66 67 @Override 68 public void run() { 69 for (int i = 0; i < 10; i++) { 70 clerk.sale(); 71 } 72 } 73 } 74 75 public class TestProductorAndConsumer { 76 77 public static void main(String[] args) { 78 Clerk clerk = new Clerk(); 79 80 Productor productor = new Productor(clerk); 81 Consumer consumer = new Consumer(clerk); 82 83 new Thread(productor, "Productor A").start(); 84 new Thread(consumer, "Consumer B").start(); 85 } 86 }
运行程序，不再死循环：
但是，如果现在有两个（多个）消费者线程和生产者线程，并且我们在生产者类的run方法中添加一个sleep()方法的执行，情况会如何呢？
1 package concurrent; 2 3 //店员类 4 class Clerk { 5 private int product = 0; 6 7 // 进货 8 public synchronized void get() { 9 if (product >= 1) { 10 System.out.println("产品已满！"); 11 12 // 等待 13 try { 14 this.wait(); 15 } catch (InterruptedException e) { 16 e.printStackTrace(); 17 } 18 } 19 System.out.println(Thread.currentThread().getName() + ":" + ++product); 20 // 唤醒 21 this.notifyAll(); 22 } 23 24 // 售货 25 public synchronized void sale() { 26 if (product <= 0) { 27 System.out.println("缺货！"); 28 // 等待 29 try { 30 this.wait(); 31 } catch (InterruptedException e) { 32 e.printStackTrace(); 33 } 34 } 35 System.out.println(Thread.currentThread().getName() + ":" + --product); 36 // 唤醒 37 this.notifyAll(); 38 } 39 } 40 41 // 生产者类 42 class Productor implements Runnable { 43 44 private Clerk clerk; 45 46 public Productor(Clerk clerk) { 47 this.clerk = clerk; 48 } 49 50 @Override 51 public void run() { 52 for (int i = 0; i < 10; i++) { 53 try { 54 Thread.sleep(100); 55 } catch (InterruptedException e) { 56 // TODO Auto-generated catch block 57 e.printStackTrace(); 58 } 59 clerk.get(); 60 } 61 } 62 } 63 64 // 消费者类 65 class Consumer implements Runnable { 66 67 private Clerk clerk; 68 69 public Consumer(Clerk clerk) { 70 this.clerk = clerk; 71 } 72 73 @Override 74 public void run() { 75 for (int i = 0; i < 10; i++) { 76 clerk.sale(); 77 } 78 } 79 } 80 81 public class TestProductorAndConsumer { 82 83 public static void main(String[] args) { 84 Clerk clerk = new Clerk(); 85 86 Productor productor = new Productor(clerk); 87 Consumer consumer = new Consumer(clerk); 88 89 new Thread(productor, "Productor A").start(); 90 new Thread(consumer, "Consumer B").start(); 91 new Thread(productor, "Productor C").start(); 92 new Thread(consumer, "Consumer D").start(); 93 } 94 }
运行程序：
产品数量出现了负数，这肯定是错误的。错误的原因在于，当一个消费者线程遇到产品为0时，等待，并释放锁标志，然后另外一个消费者线程获取到该锁标志，由于产品仍然为0，也等待，并释放锁标志。这时候，生产者线程获取到锁，在生产一个产品后，执行notifyAll()唤醒所有线程，这时候，一个消费者线程消费一个产品使得产品为0，另外一个消费者线程再消费一个产品使得产品变为了负数，这种现象称为虚假唤醒。在Object.wait()方法的javadoc中叙述了该如何解决这种问题：
即，将get和sale方法中的if都改为while，这样，每次被唤醒后，都会再次判断产品数是否>=0：
1 package concurrent; 2 3 //店员类 4 class Clerk { 5 private int product = 0; 6 7 // 进货 8 public synchronized void get() { 9 while (product >= 1) { 10 System.out.println("产品已满！"); 11 12 // 等待 13 try { 14 this.wait(); 15 } catch (InterruptedException e) { 16 e.printStackTrace(); 17 } 18 } 19 System.out.println(Thread.currentThread().getName() + ":" + ++product); 20 // 唤醒 21 this.notifyAll(); 22 } 23 24 // 售货 25 public synchronized void sale() { 26 while (product <= 0) { 27 System.out.println("缺货！"); 28 // 等待 29 try { 30 this.wait(); 31 } catch (InterruptedException e) { 32 e.printStackTrace(); 33 } 34 } 35 System.out.println(Thread.currentThread().getName() + ":" + --product); 36 // 唤醒 37 this.notifyAll(); 38 } 39 } 40 41 // 生产者类 42 class Productor implements Runnable { 43 44 private Clerk clerk; 45 46 public Productor(Clerk clerk) { 47 this.clerk = clerk; 48 } 49 50 @Override 51 public void run() { 52 for (int i = 0; i < 10; i++) { 53 try { 54 Thread.sleep(100); 55 } catch (InterruptedException e) { 56 // TODO Auto-generated catch block 57 e.printStackTrace(); 58 } 59 clerk.get(); 60 } 61 } 62 } 63 64 // 消费者类 65 class Consumer implements Runnable { 66 67 private Clerk clerk; 68 69 public Consumer(Clerk clerk) { 70 this.clerk = clerk; 71 } 72 73 @Override 74 public void run() { 75 for (int i = 0; i < 10; i++) { 76 clerk.sale(); 77 } 78 } 79 } 80 81 public class TestProductorAndConsumer { 82 83 public static void main(String[] args) { 84 Clerk clerk = new Clerk(); 85 86 Productor productor = new Productor(clerk); 87 Consumer consumer = new Consumer(clerk); 88 89 new Thread(productor, "Productor A").start(); 90 new Thread(consumer, "Consumer B").start(); 91 new Thread(productor, "Productor C").start(); 92 new Thread(consumer, "Consumer D").start(); 93 } 94 }
运行程序，发现结果终于正常了：
转载自：http://blog.csdn.net/xiangwanpeng/article/details/54973782
【转】通过生产者消费者案例理解等待唤醒机制和虚假唤醒
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。