Java模拟生产者消费者模型【仅代码 + 注释】

模拟仓库容量为1，1个消费者，1个生产者的生产者消费者模型

package com.cskaoyan.sync;
/***
 * 模拟生产者消费者模型
 * 仓库容量为1
 * 1个消费者,1个生产者的消费者生产者模型
 */

public class Demo3 {
    public static void main(String[] args) {
        //创建仓库对象,仓库对象是被生产者和消费者共享的
        Warehouse warehouse = new Warehouse();
        //创建生产者和消费者线程
        new Thread(new Producer(warehouse),"生产者").start();
        new Thread(new Consumer(warehouse),"消费者").start();
    }
}

//生产者模型
class Producer implements Runnable{
    //生产者持有仓库对象的引用作为成员变量,方便生产手机
    private final Warehouse warehouse;

    //手机数组
    private static Phone[] phones = {
            new Phone("iphone xr",4800),
            new Phone("huawei p9",2000),
            new Phone("xiaomi",2000),
            new Phone("meizu",1000),
    };

    //私有方法,用来选择手机
    private Phone producePhone(){
        //Math.random()的取值范围:[0,1)
        return phones[(int) (Math.random() * phones.length)];
    }

    //构造器
    public Producer(Warehouse warehouse) {
        this.warehouse = warehouse;
    }

    //重写run方法
    @Override
    public void run() {
        //生产者需要先判断仓库里有没有手机
        //如果有(仓库非空),生产者阻塞
        //如果没有(仓库为空),直接生产,之后唤醒消费者进行消费手机
        //使用同步锁
        synchronized (warehouse){
            while (true){
                if (warehouse.isEmpty()){
                    //仓库为空
                    //生产手机
                    Phone phone = producePhone();
                    //放入仓库
                    warehouse.pullPhone(phone);
                    //唤醒消费者
                    warehouse.notify();
                }else {
                    try {
                        //生产者阻塞
                        warehouse.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

//消费者模型
class Consumer implements Runnable{
    //消费者持有仓库对象的引用作为成员变量,方便消费手机
    private final Warehouse warehouse;

    //构造器
    public Consumer(Warehouse warehouse) {
        this.warehouse = warehouse;
    }

    //实现Runnable接口,重写run方法
    @Override
    public void run() {
        //消费者先判断仓库里有没有手机
        //如果有的话,可以直接消费,然后唤醒生产者进程
        //如果没有的话(仓库为空),需要阻塞
        //(重点)用仓库当锁
        synchronized (warehouse){
            while (true){
                if (warehouse.isEmpty()){
                    //仓库为空
                    try {
                        warehouse.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    //仓库非空
                    warehouse.sellPhone();
                    //消费一部手机之后唤醒生产者进行手机的生产
                    warehouse.notify();
                }
            }
        }
    }
}

class Phone{
    private String name;
    private double price;

    //构造器
    public Phone(String name, double price) {
        this.name = name;
        this.price = price;
    }

    //重写toString方法
    @Override
    public String toString() {
        return "Phone{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

//仓库
class Warehouse{
    //用于被消费者和生产者进行操作的对象
    //生产者给它赋值对象,消费者给他赋值null
    private Phone phone;

    //生产者生产手机
    public void pullPhone(Phone phone){
        //只有this.phone是成员变量,形参中和方法体里面的phone都是生产者生产的
        //把生产者生产的phone存入仓库
        this.phone = phone;
        System.out.println(Thread.currentThread().getName() + "生产了一部" + phone + "手机");
    }

    //消费者消费手机
    public void sellPhone(){
        //将仓库里的phone保存下来
        Phone sellphone = phone;
        //消费手机(清空仓库)
        phone = null;
        System.out.println(Thread.currentThread().getName() + "消费了一部" + sellphone + "手机" );
    }

    //判断仓库里有无手机,有手机返回fasle,没有手机返回true
    public boolean isEmpty(){
        return phone == null;
    }
}