使用wait和notify实现生产者和消费者模式

package com.javase.wait和notify;

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

/**
 * 关于Object类中的wait和notify方法
 *     1.这两个方法不是线程对象的方法，是java中任何一个java对象都有的方法，因为这两个方法是Object类中自带的。
 *     这两个方法不是通过线程对象调用。
 *     也就是说：不能
 *          Thread t = new Thread();
 *          t.wait()或者t.notify();这样写是不正确的。
 *
 *     2.wait()方法的作用：
 *        Object o = new Object();
 *        o.wait();//该方法的调用，会让"当前线程（正在o对象上活动的线程）"进入无限期等待状态。
 *
 *     3.notify()方法的作用：
 *        Object o = new Object();
 *        o.notify();//表示唤醒正在o对象上等待的线程。
 *        还有一个notifyAll()方法，这个方法是唤醒o对象上处于等待的所有线程。
 *
 * 使用wait和notify实现生产者和消费者模式：
 *     1.什么是生产者和消费者模式？
 *           生产线程负责生产，消费线程负责消费，生产线程和消费线程要达到平衡。
 *           这是一种特殊的业务需求，在这种特殊情况下需要使用wait和notify方法。
 *
 *      2.wait()和notify()方法是建立在线程同步的基础之上，因为多线程要同时操作一个仓库，有线程安全问题。
 *
 *      3.wait方法的作用：o.wait();让正在o对象上活动的线程进入等待状态，并释放掉线程之前占有的o对象的锁。
 *
 *      4.notify方法的作用：o.notify();唤醒正在o对象上等待的线程，只是通知，不会释放o对象上之前占有的锁。
 *
 * 下面我们模拟这样一个需求：
 *      仓库我们采用list集合，假设集合中只能存储一个元素，如果集合中元素的个数是0，就表示仓库空了，
 *      如果集合中元素的个数是1，就表示仓库满了，做到生成一个消费一个。
 *
 */
public class WaitAndNotify {
    public static void main(String[] args) {
        //创建一个仓库对象，也就是list集合
        List list = new ArrayList();
        //创建生产线程对象
        Thread t1 = new Thread(new Product(list));
        //创建消费线程对象
        Thread t2 = new Thread(new Consume(list));
        //更名
        t1.setName("生产线程");
        t2.setName("消费线程");
        //启动线程
        t1.start();
        t2.start();
    }
}
//生产线程
class Product implements Runnable{
    //两个线程共享list集合（或者说共享仓库）为此将list集合作为线程的一种属性
    List list;

    //构造方法
    public Product(List list) {
        this.list = list;
    }

    //重写run()方法
    @Override
    public void run() {
        //一直生产（使用死循环来模拟一直生产）
        while (true){
            synchronized (list){//仓库是两个线程共享的对象，所以小括号中写list，保护仓库数据安全。（给仓库对象list加锁）
                if (list.size() >= 1){
                    try {
                        //当仓库中有元素，说明仓库已满，生产线程（当前线程）应该进入等待状态停止生产，并释放list集合的锁。
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //程序执行到这里说明需要生产
                Object obj = new Object();
                //把生产的产品放入仓库
                list.add(obj);
                System.out.println(Thread.currentThread().getName() + "生产一个：" + obj);
                //生产完成之后唤醒消费线程消费
                list.notify();
            }
        }
    }
}
//消费线程
class Consume implements Runnable{
    //两个线程共享list集合（或者说共享仓库）为此将list集合作为线程的一种属性
    List list;

    //构造方法
    public Consume(List list) {
        this.list = list;
    }

    //重写run()方法
    @Override
    public void run() {
        //一直消费
        while (true){
            synchronized (list){//仓库是两个线程共享的对象，所以小括号中写list，达到线程同步，保护仓库数据安全。
                if (list.size() <= 0){
                    try {
                        //当仓库中没有元素，消费线程进入等待，并释放占有的list集合的锁
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //如果程序执行到这里，说明需要消费
                Object obj = list.remove(0);
                System.out.println(Thread.currentThread().getName() + "消费了一个：" + obj );
                //消费后唤醒生产线程开始生产
                list.notify();
            }
        }
    }
}