// 以下是使用JUC的BlockingQueue,生产者生产娃哈哈矿泉水和旺仔小馒头:
import java.util.concurrent.BlockingQueue;
public class ProducerQueue implements Runnable {
public int number = 10;
private BlockingQueue<Goods> blockingQueue;
public ProducerQueue(BlockingQueue blockingQueue){
this.blockingQueue = blockingQueue;
}
@Override
public void run(){
for (int i=0;i<number;i++){
Goods goods = null;
if(i%2==0){
goods = new Goods("娃哈哈", "矿泉水");
}else {
goods = new Goods("旺仔", "小馒头");
}
System.out.println("生产者开始生产商品:"+goods.getBrand()+"--"+goods.getName());
try{
blockingQueue.put(goods);
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
}
// 生产者所生产的商品
public class Goods {
private String name;
private String brand;
public Goods(String name, String brand) {
this.name = name;
this.brand = brand;
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
// 以下是两个消费者开始消费商品:
import java.util.concurrent.*;
public class TestProducerConsumer {
public static void main(String[] args){
// 创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。
ExecutorService executorService = Executors.newCachedThreadPool();
// 创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程,如果工作线程数量达到线程池初始的最大数,则将提交的任务存入到池队列中。
ExecutorService executorService1 = Executors.newFixedThreadPool(5);
// 创建一个单线程化的Executor,即只创建唯一的工作者线程来执行任务,它只会用唯一的工作线程来执行任务,
// 保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。如果这个线程异常结束,会有另一个取代它,保证顺序执行。
// 单工作线程最大的特点是可保证顺序地执行各个任务,并且在任意给定的时间不会有多个线程是活动的。
ExecutorService executorService2 = Executors.newSingleThreadExecutor();
// 创建一个定长的线程池,而且支持定时的以及周期性的任务执行,支持定时及周期性任务执行。
ExecutorService executorService3 = Executors.newScheduledThreadPool(5);
BlockingQueue<Goods> queue = new ArrayBlockingQueue<>(5);
ProducerQueue producerQueue = new ProducerQueue(queue);
ConsumerQueue consumerQueue = new ConsumerQueue(queue);
executorService.execute(producerQueue);
executorService.execute(consumerQueue);
executorService.shutdown();
}
}