多线程使用(一)

// 以下是使用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();

    }
}