文章目录：
写在前面
在 Java 中，负责生产数据的模块是生产者，负责使用数据的模块是消费者。生产者消费者解决数据的平衡问题，即先有数据然后才能使用，没有数据时，消费者需要等待。
下面的案例中，我是这样做的：使生产者把数据存储到 List 集合中，消费者从 List 集合中取数据，使用 List 集合模拟栈。
Demo
这个类中，定义了一个list集合，以及设定了它的最大长度为3。
· 模拟入栈：向list集合中添加元素，每添加一个元素，就 this.notifyAll() 唤醒所有等待的线程：（情况一、唤醒了某个生产线程，就继续向list集合中生产新的元素；情况二：唤醒了某个消费线程，它可以消费已经生产出来的元素，如果再唤醒某个消费线程，它就必须进入等待状态了，因为list集合中已经没有元素了）。如果此时list集合中的元素数量>=MAX，那么就不能再生产了，此时就 this.wait() 进入等待状态。
· 模拟出栈：从list集合中取元素（remove方法移除元素），每移除一个元素，就this.notifyAll()唤醒所有等待的线程：（情况一、唤醒了某个消费线程，此时它需要进入等待状态，因为在它被唤醒之前，list集合中的元素已经被上一个消费线程消费完了；情况二、唤醒了某个生产线程，此时list集合中的元素数量<=MAX，所以可以正常生产）。如果此时list集合中的元素数量=0，那就不能再消费了，此时就 this.wait() 进入等待状态。
package com.szh.producerandconsumer; import java.util.ArrayList; import java.util.List; import java.util.Random; /** * 该类用来模拟栈 */ public class MyStack { //定义一个list集合模拟栈 private List<String> list=new ArrayList<>(); //栈的最大容量 private static final int MAX=3; //定义一个方法模拟入栈操作 public synchronized void push() { //当栈的容量达到最大（数据已满）,就进入等待状态 while (list.size() >= MAX) { System.out.println(Thread.currentThread().getName() + " begin wait..."); try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } String data="data--- " + new Random().nextInt(); list.add(data); System.out.println( Thread.currentThread().getName() + "添加了数据: " + data); //当多个生产者多个消费者时,使用 notify() 可能会出现假死的情况 //所以这里使用notifyAll() this.notifyAll(); } //定义一个方法模拟出栈操作 public synchronized void pop() { //如果栈中没有数据，就进入等待状态 while (list.size() == 0) { System.out.println(Thread.currentThread().getName() + " begin wait..."); try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println( Thread.currentThread().getName() + "出栈数据: " + list.remove(0) ); this.notifyAll(); } }
package com.szh.producerandconsumer; /** * */ public class ProducerThread extends Thread { private MyStack myStack; public ProducerThread(MyStack myStack) { this.myStack=myStack; } @Override public void run() { myStack.push(); } }
package com.szh.producerandconsumer; /** * */ public class ConsumerThread extends Thread { private MyStack myStack; public ConsumerThread(MyStack myStack) { this.myStack=myStack; } @Override public void run() { myStack.pop(); } }
package com.szh.producerandconsumer; /** * */ public class Test { public static void main(String[] args) { MyStack myStack = new MyStack(); ProducerThread p1 = new ProducerThread(myStack); ProducerThread p2 = new ProducerThread(myStack); ProducerThread p3 = new ProducerThread(myStack); ConsumerThread c1 = new ConsumerThread(myStack); ConsumerThread c2 = new ConsumerThread(myStack); ConsumerThread c3 = new ConsumerThread(myStack); p1.setName("生产者 1 号"); p2.setName("生产者 2 号"); p3.setName("生产者 3 号"); c1.setName("消费者 1 号"); c2.setName("消费者 2 号"); c3.setName("消费者 3 号"); p2.start(); p3.start(); c1.start(); c2.start(); c3.start(); p1.start(); } }
这种情况就是正常的，生产一个、消费一个。所以就不再解释了。
这种情况是说：首先生产者1号抢到了CPU执行权，它生产了一个，此时list集合的size=1；notifyAll()之后消费者3号抢到了CPU执行权，此时list集合中有元素，所以它可以正常的消费一个，此时list集合的size=0；notifyAll()之后又有两个消费者线程分别抢到了CPU执行权，而此时list集合size已经是0，不能消费了，所以这两个消费者线程都只能进入wait()等待状态；wait()释放锁对象之后，又有两个生产者线程分别抢到了CPU执行权，那么它们俩一看，list集合中size=0，这肯定要生产啊，于是就生产了两个元素，此时list集合的size=2；notifyAll()之后，因为消费者1号、2号还在等待呢，所以它们两个现在可以消费了，也就是运行结果图的最后两行。
这种情况是说：首先生产者1号抢到了CPU执行权，于是它可以向list集合中生产一个元素，此时list集合的size=1；notifyAll()之后，有一个消费者2号抢到了CPU执行权，因为list集合中有一个元素，所以它可以正常的消费，此时lits集合的size=0；notifyAll()之后，又有一个消费者线程抢到了CPU执行权，那list集合中没有元素了，你肯定不能再消费了，所以这个消费者线程需要wait去等待；wait()释放锁对象之后，连续两个生产者线程抢到了CPU执行权，因为list集合的size=0，所以它们俩都可以向list集合中生产元素，此时list集合的size=2；notifyAll()之后，之前等待的那两个消费者此时就可以正常的消费了，因为list集合中还有两个元素呢。
