不知道你是否遇到过面试官让你手写生产者消费者代码。别说,前段时间有小伙伴还真的遇到了这种情况。当时是一脸懵逼。

但是,俗话说,从哪里跌倒就要从哪里爬起来。既然这次被问到了,那就回去好好研究一下,争取下一次不再被虐呗。

于是,今天我决定手敲一个生产者消费者模式压压惊。(因为我也不想以后被面试官血虐啊)

生产者消费者模式,其实很简单。无非就是生产者不停的生产数据,消费者不停的消费数据。(这不废话吗,字面意思我也知道啊)

咳咳。其实,我们可以拿水池来举例。

比如,现在要用多个注水管往水池里边注水,那这些注水管就认为是生产者。从水池里边抽水的抽水管就是消费者。水池本身就是一个缓冲区,用于生产者消费者之间的通讯。

好的,跟着我的思路。

既然生产者是生产数据的,那总得定义一个数据类吧(Data)
public class Data { private int id; private int num; public int getId() {
return id; } public void setId(int id) { this.id = id; } public int getNum() {
return num; } public void setNum(int num) { this.num = num; } public Data(int
id, int num) { this.id = id; this.num = num; } public Data() { } }
以上数据,假设注水管每次注水的id和注水容量num(单位是升)都是递增的。并且,单次出水管的出水量和注水管的注水量是一一对应的。

生产者的类Producer和消费者类Consumer内部都需要维护一个阻塞队列,来存储缓冲区的数据。
public class Producer implements Runnable{ //共享阻塞队列 private
BlockingDeque<Data> queue; //是否还在运行 private volatile boolean isRunning = true;
//id生成器 private static AtomicInteger count = new AtomicInteger(); //生成随机数
private static Random random = new Random(); public
Producer(BlockingDeque<Data> queue){ this.queue = queue; } @Override public
void run() { try { while(isRunning){ //模拟注水耗时
Thread.sleep(random.nextInt(1000)); int num = count.incrementAndGet(); Data
data = new Data(num, num);
System.out.println("当前>>注水管:"+Thread.currentThread().getName()+"注水容量(L):"+num);
if(!queue.offer(data,2, TimeUnit.SECONDS)){ System.out.println("注水失败..."); } }
}catch (Exception e){ e.printStackTrace(); } } public void stop(){ isRunning =
false; } }
消费者:
public class Consumer implements Runnable{ private BlockingDeque<Data> queue ;
private static Random random = new Random(); public
Consumer(BlockingDeque<Data> queue){ this.queue = queue; } @Override public
void run() { while (true){ try { Data data = queue.take(); //模拟抽水耗时
Thread.sleep(random.nextInt(1000)); if(data != null){
System.out.println("当前<<抽水管:"+Thread.currentThread().getName()+",抽取水容量(L):"+data.getNum());
} }catch (Exception e){ e.printStackTrace(); } } } }
测试类,假设有三个注水管和三个出水管(即六个线程)同时运行。等一定时间后,所有注水管停止注水,则当水池空(阻塞队列为空)的时候,出水管也将不再出水。
public class TestProC { public static void main(String[] args) throws
InterruptedException { BlockingDeque<Data> queue = new
LinkedBlockingDeque<>(10); Producer producer1 = new Producer(queue); Producer
producer2 = new Producer(queue); Producer producer3 = new Producer(queue);
Consumer consumer1 = new Consumer(queue); Consumer consumer2 = new
Consumer(queue); Consumer consumer3 = new Consumer(queue); ExecutorService
service = Executors.newCachedThreadPool(); service.execute(producer1);
service.execute(producer2); service.execute(producer3);
service.execute(consumer1); service.execute(consumer2);
service.execute(consumer3); Thread.sleep(3000); producer1.stop();
producer2.stop(); producer3.stop(); Thread.sleep(1000); service.shutdown(); } }
运行结果如下:



到最后一次注水20L的时候,所有注水管都停止注水了,但此时水池还没空。于是,所有出水管继续消费水资源,直到最后20L也被消费完。

以上,就是一个典型的生产者消费者模式。

可以看到,这种模式有很多优点:

1)可以解耦消费者和生产者,因为它们是两个不同的类,互相之间不会产生影响。

2)支持并发。生产者只管生产数据就行了,生产完直接把数据丢到缓冲区,而不需要等消费者消费完数据才可以生产下一个数据。否则会造成阻塞,从而影响效率。

3)允许生产者和消费者有不同的处理速度。如,当生产者生产数据比较快的时候,会把消费者还没来得及处理的数据先放到缓冲区。等有空闲的消费者了,再去缓冲区拿去数据。

另外,以上的缓冲区,我们一般会使用阻塞队列。就像上边用的LinkedBlockingDeque。


这样,当队列满的时候,会阻塞生产者继续往队列添加数据,直到有消费者来消费了队列中的数据。当队列空的时候,也会阻塞消费者从队列获取数据,直到有生产者把数据放入到队列中。


阻塞队列最好使用有界队列(代码中指定的容量为10)。因为,如果生产者的速度远远大于消费者时,就会有可能造成队列的元素一直增加,直到内存耗尽。当然,这也需要看实际的业务情况。如果能保证生产者的数量在可控范围内,不会给内存造成压力,用无界队列,也未尝不可。