工作三年,小胖问我:什么是生产者消费者模式?菜到抠脚!

生产者消费者模式在我们日常工作中用得非常多,比如:在模块解耦、消息队列、分布式场景中都很常见。这个模式里有三个角色,他们之间的关系是如下图这样的:

工作三年,小胖问我:什么是生产者消费者模式?菜到抠脚!_第1张图片

  • 生产者线程:生产消息、数据
  • 消费者线程:消费消息、数据
  • 阻塞队列:作数据缓冲、平衡二者能力,避免出现"产能过剩"的情况(生产者生产速度远高于消费者消费速度 or 多个生产者对一个消费者)以及"供不应求"的情况(生产者生产速度远低于消费者消费速度 or 多个消费者对一个生产者)

从图中 3 和 4 可以知道:无论阻塞队列是满还是空都可能会产生阻塞,阻塞之后就要在合适的时候去唤醒被阻塞的线程。

Q1:那什么时候会唤醒阻塞线程?

  • 当消费者判断队列为空时,消费者线程进入等待。这期间生产者一旦往队列中放入数据,就会通知所有的消费者,唤醒阻塞的消费者线程。
  • 反之,当生产者判断队列已满,生产者线程进入等待。这期间消费者一旦消费了数据、队列有空位,就会通知所有的生产者,唤醒阻塞的生产者线程。

Q2:为什么要用这种模式?

看了上面的 Q1,大家发现没有?生产者不用管消费者的动作,消费者也不用管生产者的动作;它两之间就是通过阻塞队列通信,实现了解耦;阻塞队列的加入,平衡二者能力;生产者只有在队列满或消费者只有在队列空时才会等待,其他时间谁抢到锁谁工作,提高效率。以上就是原因~

使用 wait、notify/notifyAll 实现

上篇文章《正确使用 wait、notify/notifyAll》说过,wait 让当前线程等待并释放锁,notify 唤醒任意一个等待同一个锁的线程,notifyAll 则是唤醒所有等待该锁的线程,然后谁抢到锁,谁执行。这就是所谓的等待唤醒机制

先来看看用等待唤醒机制如何实现生产者、消费者模式的,首先是阻塞队列:

public class MyBlockingQueue {

    private int maxSize;
    private LinkedList queue;

    public MyBlockingQueue(int size) {
        this.maxSize = size;
        queue = new LinkedList<>();
    }

    public synchronized void put() throws InterruptedException {
        while (queue.size() == maxSize) {
            System.out.println("队列已满,生产者: " + Thread.currentThread().getName() +"进入等待");
            wait();
        }
        Random random = new Random();
        int i = random.nextInt();
        System.out.println("队列未满,生产者: " +
                Thread.currentThread().getName() +"放入数据" + i);

        // 队列空才去唤醒消费者,其他时间自由竞争锁
        if (queue.size() == 0) {
            notifyAll();
        }

        queue.add(i);
    }

    public synchronized void take() throws InterruptedException {
        while (queue.size() == 0) {
            System.out.println("队列为空,消费者: " + Thread.currentThread().getName() +"进入等待");
            wait();
        }

        // 队列满了才去唤醒生产者,其他时间自由竞争锁
        if (queue.size() == maxSize) {
            notifyAll();
        }

        System.out.println("队列有数据,消费者: " +
                Thread.currentThread().getName() +"取出数据: " + queue.remove());
    }

}

主要逻辑在阻塞队列这边:先看 put 方法,while 检查队列是否满?满则进入等待并主动释放锁,不满则生产数据,同时判断放入数据之前队列是否空?空则唤醒消费者(因为队列已有数据,可消费)。

再看 take 方法,while 检查队列是否空?空则进入等待并主动释放锁,不空则生产数据,同时判断取出数据之前队列是否已满?满则唤醒生产者(因为队列已有空位,可生产)。

为什么是 while 不是 if ?

大家可能有个疑问。为什么判断队列 size 进入等待状态这里是用 while,不能用 if 吗?就这个 demo 而言,是可以的。因为我们的生产者和消费者线程都只有一个,但是多线程情况下用 if 就大错特错了。想象以下情况:

  • 假设有两个消费者一个生产者。队列为空,消费者一进入等待状态,释放锁。消费者二抢到锁,进入 if(queue.size == 0) 的判断,也进入等待,释放锁。这时生产者抢到锁生产数据,队列有数据了。反过来唤醒两个消费者。
  • 消费者一抢到锁执行 wait() 后的逻辑,取完数据释放锁。这时消费者二拿到锁,执行 wait() 后的逻辑取数据,但是此时队列的数据已被消费者一取出,没有数据了,这时就会报异常了。

而用 while 为什么可以?因为不管是消费者一还是二抢到锁,循环体的逻辑之前。根据 while 的语法,它会再一次判断条件是否成立,而 if 不会。这就是用 while 不用 if 的原因。

生产者:

public class Producer implements Runnable {

    private MyBlockingQueue myBlockingQueue;

    public Producer(MyBlockingQueue myBlockingQueue) {
        this.myBlockingQueue = myBlockingQueue;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                myBlockingQueue.put();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

消费者:

public class Consumer implements Runnable{

    private MyBlockingQueue myBlockingQueue;

    public Consumer(MyBlockingQueue myBlockingQueue) {
        this.myBlockingQueue = myBlockingQueue;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                myBlockingQueue.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

测试类:

public class MyBlockingQueueTest {

    public static void main(String[] args) {
        MyBlockingQueue myBlockingQueue = new MyBlockingQueue(10);
        Producer producer = new Producer(myBlockingQueue);
        Consumer consumer = new Consumer(myBlockingQueue);
        new Thread(producer).start();
        new Thread(consumer).start();
    }

}

使用 Condition 实现

Condition 是一个多线程间协调通信的工具类,它的 await、sign/signAll 方法正好对应Object 的 wait、notify/notifyAll 方法。相比于 Object 的 wait、notify 方法,Condition 的 await、signal 结合的方式实现线程间协作更加安全和高效,所以更推荐这种方式实现线程间协作。关于 Condition 后面章节会继续研究,敬请关注

Object 的 wait、notify 方式需要结合 synchronized 关键字实现等待唤醒机制,同样 Condition 也需要结合 Lock 类-。那么这种方式如何实现生产者、消费者模式?看代码:

public class MyBlockingQueueForCondition {

    private Queue queue;
    private int max = 10;
    private ReentrantLock lock = new ReentrantLock();
    private Condition notEmpty = lock.newCondition();
    private Condition notFull = lock.newCondition();

    public MyBlockingQueueForCondition(int size) {
        this.max = size;
        queue = new LinkedList();
    }

    public void put(Integer i) throws InterruptedException {
        // 加锁
        lock.lock();
        try {
            // 队列满了,进入等待
            while (queue.size() == max) {
                System.out.println("队列已满,生产者: " + Thread.currentThread().getName() + "进入等待");
                notFull.await();
            }

            // 加入数据之前,队列为空?通知消费者,可以消费
            if (queue.size() == 0) {
                notEmpty.signalAll();
            }

            // 否则,继续生产
            queue.add(i);
        } finally {
            // 最后别忘记释放锁
            lock.unlock();
        }
    }

    public Integer take() throws InterruptedException {
        // 加锁
        lock.lock();
        try {
            // 队列无数据,进入等待
            while (queue.size() == 0) {
                System.out.println("队列为空,消费者: " + Thread.currentThread().getName() + "进入等待");
                notEmpty.await();
            }

            // 取出数据之前,队列已满?通知生产者,可以生产
            if (queue.size() == max) {
                notFull.signalAll();
            }

            // 否则,取出
            return queue.remove();
        } finally {
            // 最后别忘记释放锁
            lock.unlock();
        }
    }
}

首先,定义了一个队列以及 ReentrantLock 类型的锁,在这基础上还创建 notFull、notEmpty 两个条件,分别代表未满、不为空的条件。最后定义了 take、put 方法。

take 和 put 逻辑差不多,这里只说 put 。因为消费生产模式肯定用于多线程环境,需要保证同步。这里还是先获取锁,确保同步。之后依然是判断队列是否已满?满了进入等待并释放锁,不满则继续生产,同时判断队列在生产前是否为空,为空才去唤醒消费者。否则不唤醒,因为当队列为空消费者才进入阻塞

PS:最后是一个非常重要的细节,在 finally 里面释放锁,否则有可能出现异常无法释放锁的情况

生产者:

public class ProducerForCondition implements Runnable {

    private MyBlockingQueueForCondition myBlockingQueueForCondition;

    public ProducerForCondition(MyBlockingQueueForCondition myBlockingQueueForCondition) {
        this.myBlockingQueueForCondition = myBlockingQueueForCondition;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                myBlockingQueueForCondition.put(i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

消费者:

public class ConsumerForCondition implements Runnable{

    private MyBlockingQueueForCondition myBlockingQueueForCondition;

    public ConsumerForCondition(MyBlockingQueueForCondition myBlockingQueueForCondition) {
        this.myBlockingQueueForCondition = myBlockingQueueForCondition;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                System.out.println("消费者取出数据: " + myBlockingQueueForCondition.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

测试类:

public class MyBlockingQueueForConditionTest {

    public static void main(String[] args) {
        MyBlockingQueueForCondition myBlockingQueueForCondition = new MyBlockingQueueForCondition(10);
        ProducerForCondition producerForCondition = new ProducerForCondition(myBlockingQueueForCondition);
        ConsumerForCondition consumerForCondition = new ConsumerForCondition(myBlockingQueueForCondition);
        new Thread(producerForCondition).start();
        new Thread(consumerForCondition).start();
    }

}

使用 BlockingQueue 实现

看完前两种方式之后,有些小伙伴可能会说,实现个生产者消费者这么烦么?其实主要代码还是在阻塞队列,这点 Java 早就为我们考虑好了,它提供了 BlockingQueue 接口,并有实现类: ArrayBlockingQueue、DelayQueue、 LinkedBlockingDeque、LinkedBlockingQueue、等。(关于阻塞队列,狗哥的多线程系列后面也会讲到

我们选用最简单的 ArrayBlockingQueue 实现。它的内部也是采取 ReentrantLock 和 Condition 结合的等待唤醒机制。所以,上面的两种方式其实是为这种方式铺垫。不多比比,上代码:

public class ArrayBlockingQueueTest {

    public static void main(String[] args) {
        // 初始化长度为 10 的 ArrayBlockingQueue
        BlockingQueue queue = new ArrayBlockingQueue<>(10);
        // 生产者
        Runnable producer = () -> {
            try {
                // 放入数据
                Random random = new Random();
                while (true) {
                    queue.put(random.nextInt());
                }
            } catch (Exception e) {
                System.out.println("生产数据出错: " + e.getMessage());
            }
        };
        // 开启线程生产数据
        new Thread(producer).start();

        // 消费者
        Runnable consumer = () -> {
            try {
                // 取出数据
                while (true) {
                    System.out.println(queue.take());
                }
            } catch (Exception e) {
                System.out.println("消费数据出错: " + e.getMessage());
            }
        };
        // 开启线程消费数据
        new Thread(consumer).start();
    }

}

创建一个 ArrayBlockingQueue 并给定最大长度为 10,创建生产者和消费者。生产者在 while(true) 里面一直生产,与此同时消费者也是不断取数据,有数据就取出来。

看着是不是很简单?但其实背后 ArrayBlockingQueue 已经为我们做好了线程间通信的工作了,比如队列满了就去阻塞生产者线程,队列有空就去唤醒生产者线程等

巨人的肩膀

总结

看了这几个例子之后,相信你对生产者消费者模式也有所了解。以后面试官让你手写一个阻塞队列,肯定也难不倒你。

小福利

如果看到这里,喜欢这篇文章的话,请帮点个好看。微信搜索一个优秀的废人,关注后回复电子书送你 100+ 本编程电子书 ,不只 Java 哦,详情看下图。回复 1024送你一套完整的 java 视频教程。

资源

C语言

C++

Java

Git

Python

GO

Linux

经典必读

面试相关

前端

人工智能

设计模式

数据库

数据结构与算法

计算机基础

一个优秀的废人

你可能感兴趣的:(java并发多线程阻塞队列)