并发设计模式之生产者-消费者模式

生产者-消费者模式是一个经典的多线程设计模式，它为多线程间的协作提供了良好的解决方案。在生产者-消费者模式中，通常有两类线程，即若干个生产者和若干个消费者线程。生产者线程负责提交用户请求，消费者线程则负责处理生产者提交的任务。生产者和消费者之间通过共享内存缓冲区进行通信

如图展示了生产者-消费者模式的基本结构。3个生产者线程将在任务提交到共享内存缓冲区，消费者线程并不直接与生产者线程通信，而在共享内存缓冲区中获取任务，并进行处理

生产者-消费者模式中的内存缓冲区的主要功能是数据在多线程间的共享。此外，通过该缓冲区，可以缓解生产者和消费者间的性能差

生产者-消费者模式的核心组件是共享内存缓冲区，它作为生产者和消费者间的通信桥梁，避免了生产者和消费者的直接通信，从而将生产者和消费者进行解耦。生产者不需要知道消费者的存在，消费者也不需要知道生产者的存在。同时，由于内存缓冲区的存在，允许生产者和消费者在执行速度上存在时间差，无论是生产者在某一局部时间内速度高于消费者，或者消费者在局部时间内高于生产者，都可以通过共享内存缓冲区得到缓解，确保系统正常运行

生产者-消费者模式的主要角色有：生产者、消费者、内存缓冲区、任务、Main

• 生产者：用于提交用户请求，提取用户任务，并装入内存缓冲区
• 消费者：在内存缓冲区中提取并处理任务
• 内存缓冲区：缓存生产者提交的任务或数据，供消费者使用
• 任务：生产者想内存缓冲区提交的数据结构
• Main：使用生产者和消费者的客户端、

上图显示了生产者-消费者模式一种实现的具体结构

其中，BlockingQueue充当了共享内存缓冲区，用户维护任务或数据队列（PCData对象）。PCData对象表示一个生产任务，或者相关任务的数据。生产者对象和消费者对象均引用同一个BlockingQueue实例。生产者负责创建PCData对象，并将它加入BlockingQueue中，消费者则从BlockingQueue队列中获取PCData

下面实现一个基于生产者-消费者模式的求证书平方的并行程序

PCData作为生产者和消费者之间的共享数据模型，定义如下

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

生产者线程的实现如下

import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author kqkaiqiang.zhang
 * @create 2017-12-19 11:33
 **/
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;
        System.out.println("生产者销毁----");
    }
}

消费者实现如下，它从BlockingQueue队列中取出PCData对象，并进行相应的计算

import java.text.MessageFormat;
import java.util.Random;
import java.util.concurrent.BlockingQueue;

/**
 * @author kqkaiqiang.zhang
 * @create 2017-12-19 11:46
 **/
public class Consumer implements Runnable {
    private volatile boolean isRunning = true;

    private BlockingQueue<PCData> queue;
    private static final int SLEEPTIME = 1000;

    public Consumer(BlockingQueue<PCData> queue) {
        this.queue = queue;
    }

    public void stop() {
        isRunning = false;
        System.out.println("消费者销毁----");
    }

    @Override
    public void run() {
        System.out.println("Start Consumer id = " + Thread.currentThread().getId());
        Random random = new Random();
        try {
            while (isRunning) {
                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();
        }
    }
}

调用过程：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

/**
 * @author kqkaiqiang.zhang
 * @create 2017-12-19 11:59
 **/
public class ProducerAndConsumer {
    public static void main(String []args) throws InterruptedException {
         BlockingQueue<PCData> queue =new ArrayBlockingQueue<PCData>(100);

        Producer producer = new Producer(queue);

        Consumer consumer = new Consumer(queue);

        new Thread(producer).start();

        new Thread(consumer).start();

        Thread.sleep(5000l);
        producer.stop();

        Thread.sleep(1000l);
        consumer.stop();

    }
}