多线程&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方法的底层,可以发现这两个方法是自带锁的,所以我们在实现生产者和消费者的时候无须自己上锁,否则反而会容易因为锁的嵌套而发生死锁。
多线程&JUC:等待唤醒机制(生产者消费者模式)_第1张图片
多线程&JUC:等待唤醒机制(生产者消费者模式)_第2张图片
生产者代码:

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();
    }
}

多线程&JUC:等待唤醒机制(生产者消费者模式)_第3张图片
最后显示可能会重复打印数据,这是因为输出的语句没有放在锁里面,锁可以执行的put和take已经写死了,但是并不影响我们实际数据的并发安全性,只是不方便我们的观察罢了。

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

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

你可能感兴趣的:(多线程&JUC,java,开发语言,JUC,javase,面试)