介绍生产者-消费者模式

public class Producer implements Runnable{
	
	/*Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。
	 * 而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。
	 * 这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。*/
	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;
	}
	
	public void run(){
		PCData data = null;
		Random r = new Random();
		
		System.out.println("start producer id = "+Thread.currentThread().getId());
		
			while(isRunning){
				try {
					Thread.sleep(r.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;
	}
	
}

public class Consumer implements Runnable{

	private BlockingQueue<PCData> queue;//缓冲区
	private static final int SLEEPTIME = 1000;
	
	public Consumer(BlockingQueue<PCData> queue){
		this.queue = queue;
	}
	
	public void run() {
		System.out.println("start Consumer id = "+Thread.currentThread().getId());
		Random r= new Random();  //随机等待时间
		while(true){
			try {
				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(r.nextInt(SLEEPTIME));
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
				Thread.currentThread().interrupt();
			}
		}
	}

}

public class PCData {

	private final int intData;
	public PCData(int d) {
		intData = d;
	}
	public PCData(String d){
		intData=Integer.valueOf(d);
	}
	public int getData(){
		return intData;
	}
	public String toString(){
		return "data:"+intData;
	}
}

public static void main(String[] args) throws InterruptedException{
		BlockingQueue<PCData> queue = new LinkedBlockingQueue<PCData> (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);
		Thread.sleep(10*1000);
		/*运行消费者*/
		service.execute(consumer1);
		service.execute(consumer2);
		service.execute(consumer3);
		
		Thread.sleep(10*1000);
		/*停止生产者*/
		producer1.stop();
		producer2.stop();
		producer3.stop();
		
		Thread.sleep(3000);
		service.shutdown();
	}

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

    生产者消费者模式的核心组件是共享内存缓冲区，它作为生产者和消费者间的通信桥梁，避免了生产者和消费者之间的直接通信，从而将消费者和生产者进行解耦。生产者不需要知道消费者的存在，消费者也不需要知道生产者的存在。