生產者-消費者模式是一個經典的多執行緒設計模式，它為多執行緒間的協作提供了良好的解決方案。在生產者-消費者模式中，通常有兩類執行緒，即若干個生產者和若干個消費者執行緒。生產者執行緒負責提交使用者請求，消費者執行緒則負責處理生產者提交的任務。生產者和消費者之間通過共享記憶體緩衝區進行通訊

如圖展示了生產者-消費者模式的基本結構。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();
		}
	}
}

生產者-消費者模式能夠很好地對生產者和消費者執行緒進行解耦，優化了系統整體結構。同時，由於緩衝區的作用，允許生產者執行緒和消費者執行緒存在執行上的效能差異，從一定程度上緩解了效能瓶頸對系統性能的影響。