多线程（生产者消费者模式）之：BlockingQueue

通过 阻塞队列来实现 ：生产者消费者模型

public class ConsumerQueue implements Runnable{
    private BlockingQueue consumeQueue;

    public ConsumerQueue(BlockingQueue queue) {
        this.consumeQueue = queue;
    }

    @Override
    public void run() {
        for (int i = 0;i<10;i++) {
            try {
                System.out.println("消费者消费的编号 i=" + consumeQueue.take());
                Thread.sleep(3000);
            } catch (InterruptedException e) {
            }
        }
    }
}

public class ProducterQueue implements Runnable {
    private BlockingQueue prodecterQueue;
    public ProducterQueue(BlockingQueue queue) {
        this.prodecterQueue = queue;
    }

    @Override
    public void run() {
        for (int i=0;i<10;i++) {
            System.out.println("生成者生成事件 i= " + i);
            try {
                prodecterQueue.put(i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
 * 主程序，一端通过生成者向容器添加数据，一端通过消费者从容器取数据
 *  通过阻塞式队列实现生产者和消费者模型非常简单，它提供阻塞的方法put()和take()
 *  开发者不需要实现wait_notify代码来实现通信。
 *  在java5中提供了不同的实现方式，比如 ArrayBlockingQueue和 LinkedBlockingQueue
 *  两者都是先进先出的顺序，而ArrayLinkedQueue 是自然有界的
 *  LinkedBlockingQueue可选的边界
 */
public class PublicBoxQueue {
    public static void main(String[] args) {
        BlockingQueue publicQueue = new LinkedBlockingQueue();
        ConsumerQueue consumerQueue = new ConsumerQueue(publicQueue);
        ProducterQueue producterQueue = new ProducterQueue(publicQueue);
        Thread consumeThread = new Thread(consumerQueue);
        Thread producterThread = new Thread(producterQueue);
        consumeThread.start();
        producterThread.start();
    }
}

生成者生成事件 i= 0
生成者生成事件 i= 1
生成者生成事件 i= 2
消费者消费的编号 i=0
生成者生成事件 i= 3
生成者生成事件 i= 4
生成者生成事件 i= 5
生成者生成事件 i= 6
生成者生成事件 i= 7
生成者生成事件 i= 8
生成者生成事件 i= 9
消费者消费的编号 i=1
消费者消费的编号 i=2
消费者消费的编号 i=3
消费者消费的编号 i=4
消费者消费的编号 i=5
消费者消费的编号 i=6
消费者消费的编号 i=7
消费者消费的编号 i=8
消费者消费的编号 i=9