java 生产者消费者_executorservice linkedblockingqueue product custum-优快云博客

本文介绍了一个使用Java实现的并发编程模型——生产者消费者模型。通过创建生产者线程和消费者线程，演示了如何高效地在多线程环境中进行数据的生产和消费。模型中包括了内存缓冲区的使用、数据的生成与处理过程，以及线程间的同步与协调。

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;
	//内存缓冲区nv17777
	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 r=new Random();
		System.out.println("开始productor id="+Thread.currentThread().getId());
		
		try {
			while(isRunning){
				Thread.sleep(r.nextInt(SLEEPTIME));
				//构造任务队列
				System.out.println("数字："+count.incrementAndGet());
				data=new PCData(count.incrementAndGet());
				System.out.println(data+"放入队列");
				if(!queue.offer(data, 2, TimeUnit.SECONDS)){
					System.out.println("提交缓冲区失败："+data);
				}
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	public void stop(){
		isRunning=false;
	}
}

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("开始Consumer id="+Thread.currentThread().getId());
		Random r=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(SLEEPTIME);
				}
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
			Thread.currentThread().interrupt();
		}
	}

}

port java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;


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

}