多线程&JUC：等待唤醒机制（生产者消费者模式）

‍作者简介：一位大四、研0学生，正在努力准备大四暑假的实习
上期文章：多线程&JUC：解决线程安全问题——synchronized同步代码块、Lock锁
订阅专栏：多线程&JUC
希望文章对你们有所帮助

等待唤醒机制

等待唤醒机制也叫做生产者消费者模式，打破了以前线程间执行的随机性，生产者消费者模式能够使得线程之间是轮流运行的。是一个非常经典的多线程协作的模式。
对于两条线程，其中一条为生产者，另一条为消费者，大家都是学习过操作系统的，原理多少还是记得一些的。

对于等待唤醒机制，其只有2种情况：

1、消费者等待：若没有可以被消费者消费的数据，那么消费者就是进入wait状态，这时候生产者就可以抢占CPU生产数据，接着notify（唤醒）消费者
2、生产者等待：若已经有数据供给消费者消费，则生产者进入wait状态，消费者抢占CPU消费数据，接着notify（唤醒）生产者

在这其中可能会涉及到的方法：

方法名称	说明
void wait()	当前线程等待，直到被其他线程唤醒
void notify()	随机唤醒单个线程
void notifyAll()	唤醒所有线程

等待唤醒机制的实现

消费者代码实现

消费者和生产者中间有一个控制他们执行相应操作的核心，视为Controller，记录一些状态变量和锁对象：

public class Controller {
    /**
     * 控制消费者和生产者的执行
     */
    //表示是否有数据 0：没有 1：有
    public static int flag = 0;

    //消费者最多可以消费的数据量
    public static int count = 10;

    //锁对象
    public static Object lock = new Object();
}

接着实现消费者的逻辑：

public class Consumer extends Thread{
    @Override
    public void run() {
        while(true){
            synchronized (Controller.lock) {
                if(Controller.count == 0){
                    //消费者已经消费量了10次，退出
                    break;
                }else{
                    //先判断有无可以消费的数据
                    if(Controller.flag == 0) {
                        //若无，等待
                        //用lock调用wait方法，使得当前线程与锁进行绑定，之后唤醒就唤醒这些被绑定了的线程
                        try {
                            Controller.lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }else{
                        //若有，消费
                        System.out.println("正在消费，还可以消费" + --Controller.count + "个");
                        //消费完后唤醒生产者，唤醒绑定在这把锁上的所有线程
                        Controller.lock.notifyAll();
                        //修改控制中心的状态
                        Controller.flag = 0;
                    }
                }
            }
        }
    }
}

生产者代码实现

public class Producer extends Thread{
    @Override
    public void run() {
        while (true){
            synchronized (Controller.lock){
                if(Controller.count == 0){
                    break;
                }else{
                    if(Controller.flag == 1){
                        //已经有供给消费者进行消费的数据
                        try {
                            Controller.lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }else{
                        System.out.println("成功生产");
                        Controller.lock.notifyAll();
                        Controller.flag = 1;
                    }
                }
            }
        }
    }
}

最后编写测试类代码验证：

public class ThreadDemo {
    public static void main(String[] args) {
        //创建线程对象
        Producer producer = new Producer();
        Consumer consumer = new Consumer();
        //给线程设置名字
        producer.setName("生产者");
        consumer.setName("消费者");
        //开启线程
        producer.start();
        consumer.start();
    }
}

阻塞队列实现等待唤醒机制

何为阻塞队列？其实就是连接生产者和消费者的一个队列，管理着数据，分别供消费者take和生产者的put，如果put不进去或者take不出，则说明队列满了或者空了，这时候就会进入阻塞状态。

阻塞队列BlockingQueue本身实现了Iterable、Collection、Queue的接口，无法直接实例化，但是其具有2个实现类：

1、ArrayBlockingQueue：底层为数组，有界
2、LinkedBlockingQueue：底层为链表，无界（不是真正的无界，最大为int的最大范围，只是无须指定范围）

利用阻塞队列来实现是很便捷的，因为我们可以查看put和take方法的底层，可以发现这两个方法是自带锁的，所以我们在实现生产者和消费者的时候无须自己上锁，否则反而会容易因为锁的嵌套而发生死锁。


生产者代码：

public class Producer extends Thread{

    ArrayBlockingQueue<String> queue;

    public Producer(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            //直接不断的把数据放进阻塞队列，如果满了它自己会阻塞
            try {
                queue.put("数据");
                System.out.println("消费者生产了一个数据到阻塞队列");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

消费者代码：

public class Consumer extends Thread{

    ArrayBlockingQueue<String> queue;

    public Consumer(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true){
            try {
                String take = queue.take();
                System.out.println(take);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

测试类：

public class ThreadDemo {
    /**
     * 使用阻塞队列实现等待唤醒机制，要保证生产者和消费者用的是同一个阻塞队列
     */
    public static void main(String[] args) {
        //创建一个可以存放1个数据的阻塞队列
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(1);
        //创建生产者和消费者对象，并把阻塞队列传递过去，使得它们使用同一个阻塞队列
        Producer producer = new Producer(queue);
        Consumer consumer = new Consumer(queue);

        producer.setName("生产者");
        consumer.setName("消费者");

        producer.start();
        consumer.start();
    }
}

最后显示可能会重复打印数据，这是因为输出的语句没有放在锁里面，锁可以执行的put和take已经写死了，但是并不影响我们实际数据的并发安全性，只是不方便我们的观察罢了。

至此，阻塞队列实现等待唤醒机制的demo已经跑通了，阻塞队列底层的执行实际上是异步的，可以解决在实际生产环境中的超卖问题，具体可以看我之前的文章：
Redis：原理速成+项目实战——Redis实战9（秒杀优化）

当然，主流的方法还是使用消息队列RabbitMQ或Kafka，这个大家可以自行去了解。