多线程必考的「生产者 - 消费者」模型,看这篇文章就够了

开发 前端
生产者 - 消费者模型 Producer-consumer problem 是一个非常经典的多线程并发协作的模型,在分布式系统里非常常见。也是面试中无论中美大厂都非常爱考的一个问题,对应届生问的要少一些,但是对于有工作经验的工程师来说,非常爱考。

[[341897]]

 生产者 - 消费者模型 Producer-consumer problem 是一个非常经典的多线程并发协作的模型,在分布式系统里非常常见。也是面试中无论中美大厂都非常爱考的一个问题,对应届生问的要少一些,但是对于有工作经验的工程师来说,非常爱考。

这个问题有非常多的版本和解决方式,在本文我重点是和大家壹齐理清思路,由浅入深的思考问题,保证大家看完了都能有所收获。

问题背景

简单来说,这个模型是由两类线程构成:

  • 生产者线程:“生产”产品,并把产品放到一个队列里;
  • 消费者线程:“消费”产品。
  • 队列:数据缓存区。

有了这个队列,生产者就只需要关注生产,而不用管消费者的消费行为,更不用等待消费者线程执行完;消费者也只管消费,不用管生产者是怎么生产的,更不用等着生产者生产。

所以该模型实现了生产者和消费者之间的解藕和异步。

什么是异步呢?

比如说你和你女朋友打电话,就得等她接了电话你们才能说话,这是同步。

但是如果你跟她发微信,并不需要等她回复,她也不需要立刻回复,而是等她有空了再回,这就是异步。

但是呢,生产者和消费者之间也不能完全没有联系的。

  • 如果队列里的产品已经满了,生产者就不能继续生产;
  • 如果队列里的产品从无到有,生产者就得通知一下消费者,告诉它可以来消费了;
  • 如果队列里已经没有产品了,消费者也无法继续消费;
  • 如果队列里的产品从满到不满,消费者也得去通知下生产者,说你可以来生产了。

所以它们之间还需要有协作,最经典的就是使用 Object 类里自带的 wait() 和 notify() 或者 notifyAll() 的消息通知机制。

上述描述中的等着,其实就是用 wait() 来实现的;

而通知,就是 notify() 或者 notifyAll() 。

那么基于这种消息通知机制,我们还能够平衡生产者和消费者之间的速度差异。

如果生产者的生产速度很慢,但是消费者消费的很快,就像是我们每月工资就发两次,但是每天都要花钱,也就是 1:15.

那么我们就需要调整生产者(发工资)为 15 个线程,消费者保持 1 个线程,这样是不是很爽~

总结下该模型的三大优点:

解藕,异步,平衡速度差异。

wait()/notify()

接下来我们需要重点看下这个通知机制。

wait() 和 notify() 都是 Java 中的 Object 类自带的方法,可以用来实现线程间的通信。

在上一节讲的 11 个 APIs 里我也提到了它,我们这里再展开讲一下。

wait() 方法是用来让当前线程等待,直到有别的线程调用 notify() 将它唤醒,或者我们可以设定一个时间让它自动苏醒。

调用该方法之前,线程必须要获得该对象的对象监视器锁,也就是只能用在加锁的方法下。

而调用该方法之后,当前线程会释放锁。(提示:这里很重要,也是下文代码中用 while 而非 if 的原因。)

notify() 方法只能通知一个线程,如果多个线程在等待,那就唤醒任意一个。

notifyAll() 方法是可以唤醒所有等待线程,然后加入同步队列。

这里我们用到了 2 个队列:

  • 同步队列:对应于我们上一节讲的线程状态中的 Runnable,也就是线程准备就绪,就等着抢资源了。
  • 等待队列:对应于我们上一节讲的线程状态中的 Waiting,也就是等待状态。

这里需要注意,从等待状态线程无法直接进入 Q2,而是要先重新加入同步队列,再次等待拿锁,拿到了锁才能进去 Q2;一旦出了 Q2,锁就丢了。

在 Q2 里,其实只有一个线程,因为这里我们必须要加锁才能进行操作。

实现

这里我首先建了一个简单的 Product 类,用来表示生产和消费的产品,大家可以自行添加更多的 fields。

  1. public class Product  { 
  2.     private String name
  3.  
  4.     public Product(String name) { 
  5.         this.name = name
  6.     } 
  7.  
  8.     public String getName() { 
  9.         return name
  10.     } 
  11.  
  12.     public void setName(String name) { 
  13.         this.name = name
  14.     } 

主函数里我设定了两类线程,并且这里选择用普通的 ArrayDeque 来实现 Queue,更简单的方式是直接用 Java 中的 BlockingQueue 来实现。

BlockingQueue 是阻塞队列,它有一系列的方法可以让线程实现自动阻塞,常用的 BlockingQueue 有很多,后面会单独出一篇文章来讲。

这里为了更好的理解并发协同的这个过程,我们先自己处理。

  1. public class Test { 
  2.     public static void main(String[] args) { 
  3.         Queue<Product> queue = new ArrayDeque<>(); 
  4.  
  5.         for (int i = 0; i < 100; i++) { 
  6.             new Thread(new Producer(queue, 100)).start(); 
  7.             new Thread(new Consumer(queue, 100)).start(); 
  8.         } 
  9.     } 

然后就是 Producer 和 Consumer 了。

  1. public class Producer implements Runnable{ 
  2.     private Queue<Product> queue; 
  3.     private int maxCapacity; 
  4.  
  5.     public Producer(Queue queue, int maxCapacity) { 
  6.         this.queue = queue; 
  7.         this.maxCapacity = maxCapacity; 
  8.     } 
  9.  
  10.     @Override 
  11.     public void run() { 
  12.         synchronized (queue) { 
  13.             while (queue.size() == maxCapacity) { //一定要用 while,而不是 if,下文解释 
  14.                 try { 
  15.                     System.out.println("生产者" + Thread.currentThread().getName() + "等待中... Queue 已达到最大容量,无法生产"); 
  16.                     wait(); 
  17.                     System.out.println("生产者" + Thread.currentThread().getName() + "退出等待"); 
  18.                 } catch (InterruptedException e) { 
  19.                     e.printStackTrace(); 
  20.                 } 
  21.             } 
  22.             if (queue.size() == 0) { //队列里的产品从无到有,需要通知在等待的消费者 
  23.                 queue.notifyAll(); 
  24.             } 
  25.             Random random = new Random(); 
  26.             Integer i = random.nextInt(); 
  27.             queue.offer(new Product("产品"  + i.toString())); 
  28.             System.out.println("生产者" + Thread.currentThread().getName() + "生产了产品:" + i.toString()); 
  29.         } 
  30.     } 

其实它的主逻辑很简单,我这里为了方便演示加了很多打印语句才显得有点复杂。

我们把主要逻辑拎出来看:

  1. public void run() { 
  2.        synchronized (queue) { 
  3.            while (queue.size() == maxCapacity) { //一定要用 while,而不是 if,下文解释 
  4.                try { 
  5.                    wait(); 
  6.                } catch (InterruptedException e) { 
  7.                    e.printStackTrace(); 
  8.                } 
  9.            } 
  10.            if (queue.size() == 0) { 
  11.                queue.notifyAll(); 
  12.            } 
  13.            queue.offer(new Product("产品"  + i.toString())); 
  14.        } 
  15.    } 

这里有 3 块内容,再对照这个过程来看:

  1. 生产者线程拿到锁后,其实就是进入了 Q2 阶段。首先检查队列是否容量已满,如果满了,那就要去 Q3 等待;
  2. 如果不满,先检查一下队列原本是否为空,如果原来是空的,那就需要通知消费者;
  3. 最后生产产品。

这里有个问题,为什么只能用 while 而不是 if?

其实在这一小段,生产者线程经历了几个过程:

  1. 如果队列已满,它就没法生产,那也不能占着位置不做事,所以要把锁让出来,去 Q3 - 等待队列 等着;
  2. 在等待队列里被唤醒之后,不能直接夺过锁来,而是要先加入 Q1 - 同步队列 等待资源;
  3. 一旦抢到资源,关门上锁,才能来到 Q2 继续执行 wait() 之后的活,但是,此时这个队列有可能又满了,所以退出 wait() 之后,还需要再次检查 queue.size() == maxCapacity 这个条件,所以要用 while。

那么为什么可能又满了呢?

因为线程没有一直拿着锁,在被唤醒之后,到拿到锁之间的这段时间里,有可能其他的生产者线程先拿到了锁进行了生产,所以队列又经历了一个从不满到满的过程。

总结:在使用线程的等待通知机制时,一般都要在 while 循环中调用 wait() 方法。

消费者线程是完全对称的,我们来看代码。

  1. public class Consumer implements Runnable{ 
  2.     private Queue<Product> queue; 
  3.     private int maxCapacity; 
  4.  
  5.     public Consumer(Queue queue, int maxCapacity) { 
  6.         this.queue = queue; 
  7.         this.maxCapacity = maxCapacity; 
  8.     } 
  9.  
  10.     @Override 
  11.     public void run() { 
  12.         synchronized (queue) { 
  13.             while (queue.isEmpty()) { 
  14.                 try { 
  15.                     System.out.println("消费者" + Thread.currentThread().getName() + "等待中... Queue 已缺货,无法消费"); 
  16.                     wait(); 
  17.                     System.out.println("消费者" + Thread.currentThread().getName() + "退出等待"); 
  18.                 } catch (InterruptedException e) { 
  19.                     e.printStackTrace(); 
  20.                 } 
  21.             } 
  22.             if (queue.size() == maxCapacity) { 
  23.                 queue.notifyAll(); 
  24.             } 
  25.  
  26.             Product product = queue.poll(); 
  27.             System.out.println("消费者" + Thread.currentThread().getName() + "消费了:" + product.getName()); 
  28.         } 
  29.     } 

结果如下:

小结

生产者 - 消费者问题是面试中经常会遇到的题目,本文首先讲了该模型的三大优点:解藕,异步,平衡速度差异,然后讲解了等待/通知的消息机制以及在该模型中的应用,最后进行了代码实现。

文中所有代码已经放到了我的 Github 上:https://github.com/xiaoqi6666/NYCSDE。

这个 Github 汇总了我所有的文章和资料,之后也会一直更新和维护,还希望大家给小齐点个 Star,你们的支持和认可,就是我创作的最大动力,我们下篇文章见!

本文转载自微信公众号「码农田小齐」,可以通过以下二维码关注。转载本文请联系码农田小齐公众号。

 

责任编辑:武晓燕 来源: 码农田小齐
相关推荐

2012-02-14 12:31:27

Java

2017-05-16 12:30:21

Python多线程生产者消费者模式

2021-12-22 11:00:05

模型Golang语言

2015-08-26 09:39:30

java消费者

2017-03-30 22:41:55

虚拟化操作系统软件

2009-08-13 13:14:31

C#生产者和消费者

2021-11-10 07:47:48

Traefik边缘网关

2019-09-25 09:17:43

物联网技术信息安全

2024-03-14 11:58:43

2022-05-27 08:18:00

HashMapHash哈希表

2018-10-31 17:22:25

AI人工智能芯片

2021-08-31 10:26:24

存储

2018-08-17 09:14:43

饿了么容器演进

2019-10-31 09:48:53

MySQL数据库事务

2022-08-26 05:22:21

RabbitMQ架构

2021-04-20 08:32:51

消息MQ队列

2017-03-07 15:35:26

Android适配 界面

2021-04-09 10:03:12

大数据exactly-onc

2021-12-28 12:01:59

Kafka 消费者机制

2020-10-13 07:44:40

缓存雪崩 穿透
点赞
收藏

51CTO技术栈公众号