Java实现生产者消费者问题，虚假唤醒

这里需要注意的是判断条件时候，为了避免虚假唤醒，我们需要使用while来判断，而不是使用if，因为if只会判断一次条件，而while的条件不符合就会一直在里面循环。
这里解释一下虚假唤醒，之前看到的，但是找不到出处了，如果有朋友知道，希望可以指出。

什么是虚假唤醒？
举个例子，我们现在有一个生产者-消费者队列和三个线程。

1） 1号线程从队列中获取了一个元素，此时队列变为空。

2） 2号线程也想从队列中获取一个元素，但此时队列为空，2号线程便只能进入阻塞(cond.wait())，等待队列非空。

3） 这时，3号线程将一个元素入队，并调用cond.notify()唤醒条件变量。

4） 处于等待状态的2号线程接收到3号线程的唤醒信号，便准备解除阻塞状态，执行接下来的任务(获取队列中的元素)。

5） 然而可能出现这样的情况：当2号线程准备获得队列的锁，去获取队列中的元素时，此时1号线程刚好执行完之前的元素操作，返回再去请求队列中的元素，1号线程便获得队列的锁，检查到队列非空，就获取到了3号线程刚刚入队的元素，然后释放队列锁。

6） 等到2号线程获得队列锁，判断发现队列仍为空，1号线程“偷走了”这个元素，所以对于2号线程而言，这次唤醒就是“虚假”的，它需要再次等待队列非空。

而对应到程序里，假设出现多个生产者消费者，就可能出现比如生产者生产了共11个面包放到了仓库里。具体程序如下，这里只列举了最简单的一个生产者一个消费者。

package ProcessAndThread.thread.producerANDcustomer;

import java.util.ArrayList;
import java.util.List;

/**
 * 1、使用wait方法和notify方法实现"生产者和消费者模式"
 * 2、什么是"生产者消费者模式"？
 *  生产线程负责生产，消费线程负责消费
 *  生产线程和消费线程要达到均衡，这是一种特殊的业务需求，在这种特殊的情况下需要使用wait方法和notify方法
 * 3、wait方法和notify方法不是线程对象的方法，是普通Java对象的方法
 * 4、wait方法和notify方法建立在线程同步的基础之上，因为多线程要同时操作一个仓库，有线程安全问题
 * 5、wait方法作用：o.wai()让正在o对象活动的线程t进入等待状态，并且释放掉t线程之前占有的o对象的锁
 * 6、notify方法作用：o.notify()让正在o对象上等待的线程被唤醒，只是通知不会释放o对象上之前占有的锁
 * 7、模拟这样一个需求
 *  仓库我们采用List集合，集合中只能存1个元素，1个元素就代表仓库满了
 *  如果List集合中元素的个数为0，就表示仓库空了；保证List集合中永远都是最多存储1个元素
 *  必须做到这种效果：生产1个消费1个
 */
public class Test {
    public static void main(String[] args) {
        //创建一个仓库对象，共享的
        List list = new ArrayList();
        //创建两个线程
        //生产者线程
        Thread t1 = new Thread(new Producer(list));
        //消费者线程
        Thread t2 = new Thread(new Customer(list));
        t1.setName("生产者线程");
        t2.setName("消费者线程");
        t1.start();
        t2.start();
    }
}
//生产线程
class Producer implements Runnable {
    private List list;

    public Producer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        //一直生产
        while (true) {
            //给仓库对象list加锁
            synchronized (list) {
                while (list.size() == 10) {
                    //唤醒
                    list.notify();
                    System.out.println("当前仓库已满");
                    //当前线程进入等待状态，并且释放producer之前占有的list集合的锁
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //生产
                Object object = new Object();
                list.add(object);
                System.out.println(Thread.currentThread().getName() + "--->" + object);
                //唤醒
                list.notify();
            }

        }
    }
}
//消费线程
class Customer implements Runnable {
    private List list;

    public Customer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        //一直消费
        while (true) {
            //给仓库对象list加锁
            synchronized (list) {
                while (list.size() == 0) {
                    //唤醒
                    list.notify();
                    System.out.println("当前仓库已空");
                    //当前线程进入等待状态，并且释放customer之前占有的list集合的锁
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //消费
                Object object = list.remove(0);
                System.out.println(Thread.currentThread().getName() + "--->" + object);
                //唤醒
                list.notify();
            }

        }
    }
}