多线程案例（二）：阻塞队列

1 解决的问题

 阻塞队列是并发编程的一个重要基础组件,帮助我们实现"生产者-消费者模型";生产者-消费者模型就是通过一个容器来解决生产者和消费者的强耦合问题;生产者和消费者彼此之间不直接通讯,而是用过阻塞队列来进行通讯,所以生产者生产完数据之后不用等待消费者处理,直接扔给阻塞队列;消费者不找生产者要数据,而是直接从阻塞队列里取,阻塞队列就相当于一个缓冲区,平衡了生产主的和消费者的处理能力;这个阻塞队列就是用来给生产者和消费者解耦的.
 阻塞队列是一个先进先出的队列:

• 入队列的时候如果发现队列满了,就会阻塞,直到有其他线程调用出队列操作,让队列中有空位置之后,才能继续入队列;
• 出队列的时候如果发现队列空了,也会阻塞,直到有其他线程调用入队列操作,让队列中有元素之后,才能继续出队列.

2 实现

 阻塞队列是基于数组的方式来实现的.
代码实现如下:

public class ThreadDemo {
    static class BlockingQueue {
        private int[] array = new int[1000];
        private volatile int head = 0;
        private volatile int tail = 0;
        //head和tail构成的是一个前闭后开区间
        //当两者重合的时候,可能表示队列为空,也可能是队列满,
        //为了区分是空还是满,就需要额外引入一个size来表示.
        private volatile int size = 0;

        public void put(int value) throws InterruptedException {
            synchronized (this) {
                while(size == array.length) {
                    wait();
                }
                //把value放到队尾即可
                array[tail] = value;
                tail++;
                if(tail == array.length) {
                    tail = 0;
                }
                size++;
                notify();
            }
        }
        //阻塞版本的出队列,用了不同的名字
        public int take() throws InterruptedException {
            int ret = -1;
            synchronized (this) {
                while(size == 0) {
                    wait();
                }
                ret = array[head];
                head++;
                if(head == array.length) {
                    head = 0;
                }
                size--;

                notify();
            }
            return ret;
        }
    }
    public static void main(String[] args) {
        BlockingQueue blockingQue = new BlockingQueue();
        Thread producer = new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    try {
                        blockingQue.put(i);
                        System.out.println("生产元素: " + i);
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        producer.start();

        Thread consumer = new Thread() {
            @Override
            public void run() {
                while (true) {
                    try {
                        int ret = blockingQue.take();
                        System.out.println("消费元素: " + ret);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        consumer.start();
    }
}

针对以上代码,我们进行两次测试:
 第一次测试:我们让消费者消费的快一些,生产者生产的慢一些,运行结果如下:

通过运行结果可以发现,消费者线程会阻塞等待,每次有新生产元素的时候,消费者才开始消费.
 第二次测试:我们让消费者消费的慢一些,生产者生产的快一些,修改如下:

运行结果为:

通过运行结果可以发现,生产者线程刚开始的时候会快速的往队列中插入元素,插入满了之后就会阻塞等待;随后消费者线程每次消费一个元素,生产者才能生产新的元素.
注意: 一般在使用wait的时候,都建议搭配while使用.