【多线程】Java中的阻塞队列（1）

一、阻塞队列

什么是阻塞队列？

阻塞队列（BlockingQueue）是一个支持两个附加操作的队列，这两个附加的操作是：在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的队列会等待队列可用。阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。

二、BlockingQueue的核心方法

1. 放入数据

• offer（anObject）：表示如果可能的话，将anObject加到BlockingQueue里，即如果BlockingQueue可以容纳，则返回true，否则返回false（本方法不阻塞当前执行方法的线程）
• offer（(E o, long timeout, TimeUnit unit）：可以设定等待的时间，如果在指定的时间内，还不能往队列中加入BlockingQueue，则返回失败
• put（anObject）：把anObject加到BlockingQueue里，如果BlockQueue没有空间，则调用此方法的线程被阻断直到BlockingQueue里面有空间再继续 

1. 获取数据

•  poll（time）：取走BlockingQueue里排在首位的对象，若不能立即取出，则可以等time参数规定的时间，取不到时返回null
• poll（long timeout, TimeUnit unit）：从BlockingQueue取出一个队首的对象，如果在指定时间内，队列一旦有数据可取，则立即返回队列中的数据，否则直到时间超时还没有数据可取，返回失败
• take（）：取走BlockingQueue里排在首位的对象，若BlockingQueue为空，阻断进入等待状态直到BlockingQueue有新的数据被加入
• drainTo（）：一次性从BlockingQueue获取所有可用的数据对象（还可以指定获取数据的个数），通过该方法，可以提升获取数据效率；不需要多次分批加锁或释放锁

三、常见BlockingQueue

1、ArrayBlockingQueue

基于数组的阻塞队列实现，在ArrayBlockingQueue内部，维护了一个定长数组，以便缓存队列中的数据对象，这是一个常用的阻塞队列，除了一个定长数组外，ArrayBlockingQueue内部还保存着两个整形变量，分别标识着队列的头部和尾部在数组中的位置

ArrayBlockingQueue在生产者放入数据和消费者获取数据，都是共用同一个锁对象，由此也意味着两者无法真正并行运行，这点尤其不同于LinkedBlockingQueue；ArrayBlockingQueue和LinkedBlockingQueue间还有一个明显的不同之处在于，前者在插入或删除元素时不会产生或销毁任何额外的对象实例，而后者则会生成一个额外的Node对象。这在长时间内需要高效并发的处理大批量数据的系统中，其对于GC的影响还是存在一定的区别。而在创建ArrayBlockingQueue时，我们还可以控制对象的内部锁是否采用公平锁，默认采用非公平锁

ArrayBlockingQueue实现简单的生产者消费者模型：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

class Apple {
    public Apple() {
    }
}

public class AppleTest {//启动两个线程额，队列最大容量为5
    private final static BlockingQueue<Apple> queue = new ArrayBlockingQueue<Apple>(5);

    public static void main(String[] args) {
        for (int i = 0; i < 2; i++) {
              new Thread(new AppleProducer(queue)).start();
              new Thread(new AppleConsumer(queue)).start();
        }
    }
}


//生产者
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

public class AppleProducer implements Runnable {

    private final BlockingQueue<Apple> queue;

    public AppleProducer(BlockingQueue<Apple> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            try {
                TimeUnit.MILLISECONDS.sleep(100);
                queue.put(new Apple());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("生产了一个苹果，当前队列的容量为：" + queue.size());
        }
    }
}

//消费者
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

public class AppleConsumer implements Runnable {
    private final BlockingQueue<Apple> queue;
    public AppleConsumer(BlockingQueue<Apple> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            try {
                TimeUnit.MILLISECONDS.sleep(1000);
                queue.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("吃掉了一个苹果，当前队列的容量为：" + queue.size());
        }
    }
}

2、LinkedBlockingQueue

基于链表的阻塞队列，同ArrayBlockingQueue类似，其内部也维持着一个数据缓冲队列（该队列由一个链表构成），当生产者往队列中放入一个数据时，队列会从生产者手中获取数据，并缓存在队列内部，而生产者立即返回；只有当队列缓冲区达到最大值缓存容量时（LinkecBlockingQueue可以通过构造函数指定该值），才会阻塞生产者队列，直到消费者从队列中消费掉一份数据，生产者线程会被唤醒，反之对于消费者这端的处理也基于同样的原理。而LinkedBlockingQueue之所以能够高效的处理并发数据，还因为其对于生产者端和消费者端分别采用了独立的锁来控制数据同步，这也意味着在高并发的情况下生产者和消费者可以并行地操作队列中的数据，以此来提高整个队列的并发性能。

 

参考内容：https://www.cnblogs.com/tjudzj/p/4454490.html