点击查看原文: http://www.joyhwong.com/2016/11/19/并发设计模式之生产者-消费者模式/
生产者-消费者模式是一个经典的多线程设计模式,它为多线程间的协作提供了良好的解决方案。在生产者-消费者模式中,通常有两类线程,即若干个生产者和若干个消费者线程。生产者线程负责提交用户请求,消费者线程则负责处理生产者提交的任务。生产者和消费者之间通过共享内存缓冲区进行通信
如图展示了生产者-消费者模式的基本结构。3个生产者线程将在任务提交到共享内存缓冲区,消费者线程并不直接与生产者线程通信,而在共享内存缓冲区中获取任务,并进行处理
生产者-消费者模式中的内存缓冲区的主要功能是数据在多线程间的共享。此外,通过该缓冲区,可以缓解生产者和消费者间的性能差
生产者-消费者模式的核心组件是共享内存缓冲区,它作为生产者和消费者间的通信桥梁,避免了生产者和消费者的直接通信,从而将生产者和消费者进行解耦。生产者不需要知道消费者的存在,消费者也不需要知道生产者的存在。同时,由于内存缓冲区的存在,允许生产者和消费者在执行速度上存在时间差,无论是生产者在某一局部时间内速度高于消费者,或者消费者在局部时间内高于生产者,都可以通过共享内存缓冲区得到缓解,确保系统正常运行
生产者-消费者模式的主要角色有:生产者、消费者、内存缓冲区、任务、Main
- 生产者:用于提交用户请求,提取用户任务,并装入内存缓冲区
- 消费者:在内存缓冲区中提取并处理任务
- 内存缓冲区:缓存生产者提交的任务或数据,供消费者使用
- 任务:生产者想内存缓冲区提交的数据结构
- Main:使用生产者和消费者的客户端
上图显示了生产者-消费者模式一种实现的具体结构
其中,BlockingQueue充当了共享内存缓冲区,用户维护任务或数据队列(PCData对象)。PCData对象表示一个生产任务,或者相关任务的数据。生产者对象和消费者对象均引用同一个BlockingQueue实例。生产者负责创建PCData对象,并将它加入BlockingQueue中,消费者则从BlockingQueue队列中获取PCData
下面实现一个基于生产者-消费者模式的求证书平方的并行程序
PCData作为生产者和消费者之间的共享数据模型,定义如下
package com.joyhwong;
public final class PCData {
private final int intData;
public PCData(int intData) {
this.intData = intData;
}
public PCData(String d) {
this.intData = Integer.valueOf(d);
}
public int getData() {
return intData;
}
@Override
public String toString() {
return "data: " + intData;
}
}
生产者线程的实现如下
package com.joyhwong;
import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
public class Producer implements Runnable {
private volatile boolean isRunning = true;
private BlockingQueue<PCData> queue;
private static AtomicInteger count = new AtomicInteger();
private static final int SLEEPTIME = 1000;
public Producer(BlockingQueue<PCData> queue) {
this.queue = queue;
}
@Override
public void run() {
PCData data = null;
Random random = new Random();
System.out.println("start producer id = " + Thread.currentThread().getId());
try {
while (isRunning) {
Thread.sleep(random.nextInt(SLEEPTIME));
data = new PCData(count.incrementAndGet());
System.out.println(data + " is put into queue");
if (!queue.offer(data, 2, TimeUnit.SECONDS)) {
System.out.println("failed to put data: " + data);
}
}
} catch (InterruptedException e) {
e.printStackTrace();
Thread.currentThread().interrupt();
}
}
public void stop() {
isRunning = false;
}
}
消费者实现如下,它从BlockingQueue队列中取出PCData对象,并进行相应的计算
package com.joyhwong;
import java.text.MessageFormat;
import java.util.Random;
import java.util.concurrent.BlockingQueue;
public class Consumer implements Runnable {
private BlockingQueue<PCData> queue;
private static final int SLEEPTIME = 1000;
public Consumer(BlockingQueue<PCData> queue) {
this.queue = queue;
}
@Override
public void run() {
System.out.println("Start Consumer id = " + Thread.currentThread().getId());
Random random = new Random();
try {
while (true) {
PCData data = queue.take();
if (null != data) {
int re = data.getData() * data.getData();
System.out.println(MessageFormat.format("{0}*{1}={2}", data.getData(), data.getData(), re));
Thread.sleep(random.nextInt(SLEEPTIME));
}
}
} catch (InterruptedException e) {
e.printStackTrace();
Thread.currentThread().interrupt();
}
}
}
在主函数中,创建3个生产者和3个消费者,并让它们协作运行。在主函数的实现中,定义LinkedBlockingQueue作为BlockingQueue的实现类
package com.joyhwong;
import java.text.MessageFormat;
import java.util.Random;
import java.util.concurrent.BlockingQueue;
public class Consumer implements Runnable {
private BlockingQueue<PCData> queue;
private static final int SLEEPTIME = 1000;
public Consumer(BlockingQueue<PCData> queue) {
this.queue = queue;
}
@Override
public void run() {
System.out.println("Start Consumer id = " + Thread.currentThread().getId());
Random random = new Random();
try {
while (true) {
PCData data = queue.take();
if (null != data) {
int re = data.getData() * data.getData();
System.out.println(MessageFormat.format("{0}*{1}={2}", data.getData(), data.getData(), re));
Thread.sleep(random.nextInt(SLEEPTIME));
}
}
} catch (InterruptedException e) {
e.printStackTrace();
Thread.currentThread().interrupt();
}
}
}
生产者-消费者模式能够很好地对生产者和消费者线程进行解耦,优化了系统整体结构。同时,由于缓冲区的作用,允许生产者线程和消费者线程存在执行上的性能差异,从一定程度上缓解了性能瓶颈对系统性能的影响。