什么是阻塞队列？
一个支持两个附加操作的队列。这两个附加操作是：在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程会等待队列可用。阻塞队列常用于生产者和消费者场景。
非阻塞队列与阻塞队列处理方法对比：
非阻塞队列中几个主要方法有：
add（E e）：将元素e插入到队列末尾。成功返回true，失败（队列已满）抛出异常。
remove（e）：移除队首元素，成功返回true，失败（队列为空）抛出异常。
offer（E e）：将元素e插入到队列末尾，成功返回true，失败（队列已满）返回false。
poll（）：移除并获取队首元素，成功返回队首元素，失败返回null。
peek（）：获取队首元素，成功返回队首元素，失败返回null。
一般建议在使用非阻塞队列时，使用offer、poll、peek。因为这三个方法能通过返回值判断操作成功与否。非阻塞队列中的方法都没有进进行同步措施。
阻塞队列包括了非阻塞队列中的大部分方法，上面五个都存在其中。但在阻塞队列中都进行了同步措施。除此之外阻塞队列中还有几个非常有用的方法：
put（E e）：向队尾存入元素，队列满则等待。
take（）：获取队首元素，队列为空则等待。
offer（）：向队尾存入元素，队列满则等待一定时间，到达时间期限时，如果还未插入成功则返回false，否则返回true。
poll（）：获取队首元素，队列为空则等待一定时间，到达时间期限时，如果未取到则返回null，否则返回取得的元素。
Java中提供的7个阻塞队列：
ArrayBlockingQueue ：一个由数组结构组成的有界阻塞队列。
LinkedBlockingQueue ：一个由链表结构组成的有界阻塞队列。默认和最大长度为Integer.MAX_VALUE。按照先进先出的原则对元素进行排序。
PriorityBlockingQueue ：一个支持优先级排序的无界阻塞队列。默认下元素采取自然顺序排序，也可通过比较器comparator来指定元素的排序规则，按升序排序。
DelayQueue：一个使用优先级队列实现的无界阻塞队列。
SynchronousQueue：一个不存储元素的阻塞队列。每一个put操作必须等到一个take操作。否则不能继续添加元素。适用于传递性场景。
LinkedTransferQueue：一个由链表结构组成的无界阻塞TransferQueue队列。相对于其他阻塞队列LinkedTransferQueue多了tryTransfer和transfer方法。
LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列。
ArrayBlockingQueue：
一个数组实现的有界阻塞队列。按先进先出（FIFO）原则对元素进行排序。默认不保证访问者公平的访问队列。
公平访问队列：
阻塞的所有生产者线程或消费者线程，当队列可用时，可以按照阻塞的先后顺序访问队列，即先阻塞的生产者线程，可以先往队列里插入元素，先阻塞的消费者线程，可以先从队列里获取元素
我们可以ArrayBlockingQueue建立一个公平的阻塞队列，其通过可重入锁实现访问者的公平性
ArrayBlockingQueue fairQueue = new ArrayBlockingQueue(1000,true);
DelayQueue：
支持延时获取元素的无界阻塞队列。使用PriorityQueue来实现。队列中的元素必须实现Delayed接口。创建元素时可以指定多久才能从队列中获取当前元素。只有在延迟期满时才能从队列中提取元素。
DelayQueue常见运用的应用场景： 1、缓存系统的设计：可以用DelayQueue保存缓存元素的有效期，使用一个线程循环查询DelayQueue，一旦能从DelayQueue中获取元素时，表示缓存有效期到了 2、定时任务调度。使用DelayQueue保存当天将会执行的任务和执行时间，一旦从DelayQueue中获取到任务就开始执行，从比如TimerQueue就是使用DelayQueue实现的
LinkedTransferQueue：
transfer方法：
如果当前有消费者正在等待接收元素（消费者使用take()方法或带时间限制的poll()方法时），transfer方法可以把生产者传入的元素立刻transfer（传输）给消费者。如果没有消费者在等待接收元素，transfer方法会将元素存放在队列的tail节点，并等到该元素被消费者消费了才返回。
tryTransfer方法：
试探下生产者传入的元素是否能直接传给消费者。如果没有消费者等待接收元素，则返回false。和transfer方法的区别是tryTransfer方法无论消费者是否接收，方法立即返回。而transfer方法是必须等到消费者消费了才返回。对于带有时间限制的tryTransfer(E e, long timeout, TimeUnit unit)方法，则是试图把生产者传入的元素直接传给消费者，但是如果没有消费者消费该元素则等待指定的时间再返回，如果超时还没消费元素，则返回false，如果在超时时间内消费了元素，则返回true。
LinkedBlockingDeque：
可以从队列两端插入和移出元素。双端队列因其多了一个操作队列的入口。多线程同时入队时，减少了一半的竞争。相比其他队列，LinkedBlockingDeque多了addFirst，addLast，offerFirst，offerLast，peekFirst，peekLast等方法，以First单词结尾的方法，表示插入，获取（peek）或移除双端队列的第一个元素。以Last单词结尾的方法，表示插入，获取或移除双端队列的最后一个元素。另外插入方法add等同于addLast，移除方法remove等效于removeFirst。但是take方法却等同于takeFirst，不知道是不是Jdk的bug，使用时还是用带有First和Last后缀的方法更清楚。在初始化LinkedBlockingDeque时可以初始化队列的容量，用来防止其再扩容时过渡膨胀。另外双向阻塞队列可以运用在“工作窃取”模式中。
阻塞队列的实现原理：
我们采用ArrayBlockingQueue为例。先看一下其中的几个成员变量
//用以存储元素的实际是一个数组 final Object[] items; //队首元素下标 int takeIndex; //队尾元素下标 int putIndex; //队列中元素个数 int count; //可重入锁 final ReentrantLock lock; //等待条件 private final Condition notEmpty; private final Condition notFull;
构造器：
//capacity指定容量 public ArrayBlockingQueue(int capacity) {} //指定容量和公平性 public ArrayBlockingQueue(int capacity, boolean fair) {} //指定容量、公平性及用另一个集合进行初始化 public ArrayBlockingQueue(int capacity, boolean fair, Collection<? extends E> c) { }
看一下put和take方法的源码，了解一下实现：
public void put(E e) throws InterruptedException { checkNotNull(e); final ReentrantLock lock = this.lock;
//获取可中断锁 lock.lockInterruptibly(); try {
//当前元素个数等于数组长度 while (count == items.length)
//等于则让线程等待 notFull.await();
//不等于则存入元素 enqueue(e); } finally { lock.unlock(); } } //checkNotNull 校验元素是否为null，是抛出异常 private static void checkNotNull(Object v) { if (v == null) throw new NullPointerException(); } //enqueue 存入元素 private void enqueue(E x) { final Object[] items = this.items; items[putIndex] = x; if (++putIndex == items.length) putIndex = 0; count++;
//存入成功后，唤醒取元素线程 notEmpty.signal(); }
take方法实现：
public E take() throws InterruptedException { final ReentrantLock lock = this.lock;
//获取可中断锁 lock.lockInterruptibly(); try {
//当元素个数为0 while (count == 0)
//暂停线程 notEmpty.await();
//不为0，获取元素 return dequeue(); } finally { lock.unlock(); } } private E dequeue() { final Object[] items = this.items; @SuppressWarnings("unchecked") E x = (E) items[takeIndex]; items[takeIndex] = null; if (++takeIndex == items.length) takeIndex = 0; count--; if (itrs != null) itrs.elementDequeued();
//获取成功，唤醒插入线程 notFull.signal(); return x; }
take方法与put方法实现相似，put方法等待的是notFull信号，而take方法等待的是notEmpty信息。阻塞队列与我们利用wait/notify和非阻塞队列实现生产者-消费者思路类似。
阻塞队列常用场景是socket客户端数据读取和解析。读取数据的线程不断将数据放入队列。解析线程不断从队列取数据解析。
Demo：利用BlockingQueue实现生产者、消费者模型
/** * @Title: Resource * @Description: 资源池 * @date 2019/1/1810:31 */ public class Resource { private static final Logger logger = LoggerFactory.getLogger(com.imooc.demo.thread.Resource.class); private BlockingQueue blockingQueue = new LinkedBlockingDeque(10); /** * 取资源 */ public synchronized void remove(){ try { blockingQueue.take(); logger.info("消费者" + Thread.currentThread().getName() + "消耗一件资源," + "当前资源池有" + blockingQueue.size()+ "个资源"); } catch (InterruptedException e) { logger.error("remove error {}",e); } } /** * 添加资源 */ public synchronized void add(){ try { blockingQueue.put(1); logger.info("生产者" + Thread.currentThread().getName()+ "生产一件资源," + "当前资源池有" + blockingQueue.size() + "个资源"); } catch (InterruptedException e) { logger.error("add error {}",e); } } } /** * @Title: ConsumerThread * @Description: 消费者 * @date 2019/1/1810:07 */ public class ConsumerThread extends Thread{ private static final Logger logger = LoggerFactory.getLogger(ConsumerThread.class); private Resource resource; public ConsumerThread(Resource resource){ this.resource = resource; } public void run(){ while (true){ try { Thread.sleep(3000); } catch (InterruptedException e) { logger.error("ConsumerThread error {}",e); } resource.remove(); } } } /** * @Title: ProducerThread * @Description: 生产者 * @date 2019/1/1810:08 */ public class ProducerThread extends Thread{ private static final Logger logger = LoggerFactory.getLogger(ProducerThread.class); private Resource resource; public ProducerThread(Resource resource){ this.resource = resource; } public void run(){ while (true){ try { Thread.sleep(5000); } catch (InterruptedException e) { logger.error("ProducerThread error {}",e); } resource.add(); } } } /** * @Title: Client * @Description: 客户端 * @date 2019/1/1810:10 */ public class Client { public static void main(String[] args) { Resource resource =new Resource(); ProducerThread pt1 = new ProducerThread(resource); ConsumerThread ct1 = new ConsumerThread(resource); ConsumerThread ct2 = new ConsumerThread(resource); pt1.start(); ct1.start(); ct2.start(); } }