5、堵塞队列 详解（BlockingQueue、LinkedBlokcingQueue、SynchronousQueue）

1、阻塞队列有哪些

BlockingQueue：

• ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按 FIFO（先进先出）对元素进行排序。
• LinkedBlokcingQueue：是一个基于链表结构的阻塞队列，此队列按 FIFO（先进先出）对元素进行排序，吞吐量通常要高于 ArrayBlockingQueue。
• SynchronousQueue：是一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlokcingQueue。

2、什么是阻塞队列

阻塞队列，顾名思义，首先它是一个队列，而一个阻塞队列在数据结构中所起的作用大致如图所示：

• 当阻塞队列是空时，从队列中获取元素的操作将会被阻塞。
• 当阻塞队列是满时，往队列里添加元素的操作将会被阻塞。

核心方法：

	抛出异常	特殊值	阻塞	超时
插入	add(e)	offer(e)	put(e)	offer(e, time, unit)
移除	remove()	poll()	take()	poll(time, unit)
检查	element()	peek()	不可用	不可用

ArrayBlockingQueue介绍

ArrayBlockingQueue是一个阻塞式的队列，继承自AbstractBlockingQueue,间接的实现了Queue接口和Collection接口。底层以数组的形式保存数据(实际上可看作一个循环数组)。常用的操作包括 add，offer，put，remove，poll，take，peek。

根据 ArrayBlockingQueue 的名字我们都可以看出，它是一个队列，并且是一个基于数组的阻塞队列。

ArrayBlockingQueue 是一个有界队列，有界也就意味着，它不能够存储无限多数量的对象。所以在创建 ArrayBlockingQueue 时，必须要给它指定一个队列的大小。

我们先来熟悉一下 ArrayBlockingQueue 中的几个重要的方法。

行为解释：

• 抛异常：如果操作不能马上进行，则抛出异常
• 特定的值：如果操作不能马上进行，将会返回一个特殊的值，一般是 true 或者 false
• 阻塞：如果操作不能马上进行，操作会被阻塞
• 超时：如果操作不能马上进行，操作会被阻塞指定的时间，如果指定时间没执行，则返回一个特殊值，一般是 true 或者 false

插入方法：

• add(E e)：添加成功返回true，失败抛 IllegalStateException 异常
• offer(E e)：成功返回 true，如果此队列已满，则返回 false
• put(E e)：将元素插入此队列的尾部，如果该队列已满，则一直阻塞

删除方法：

• remove(Object o) ：移除指定元素,成功返回true，失败返回false
• poll()：获取并移除此队列的头元素，若队列为空，则返回 null
• take()：获取并移除此队列头元素，若没有元素则一直阻塞

检查方法：

• element() ：获取但不移除此队列的头元素，没有元素则抛异常
• peek() :获取但不移除此队列的头；若队列为空，则返回 null

保存数据的结构

/** The queued items */
final Object[] items;

可以看到，是一个Object的数组。

全局锁

/** Main lock guarding all access */
final ReentrantLock lock;

注视也说明了，这是一个掌管所有访问操作的锁。全局共享。都会使用这个锁。

ArrayBlockingQueue 进队操作采用了加锁的方式保证并发安全。源代码里面有一个 while() 判断：

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();
    }
}
public boolean offer(E e, long timeout, TimeUnit unit)
    throws InterruptedException {
    checkNotNull(e);
    long nanos = unit.toNanos(timeout);
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (count == items.length) {
        // 阻塞，知道队列不满
        // 或者超时时间已过，返回false
            if (nanos <= 0)
                return false;
            nanos = notFull.awaitNanos(nanos);
        }
        enqueue(e);
        return true;
    } finally {
        lock.unlock();
    }
}

通过源码分析，我们可以发现下面的规律：

阻塞调用方式 put(e)或 offer(e, timeout, unit)
阻塞调用时，唤醒条件为超时或者队列非满（因此，要求在出队时，要发起一个唤醒操作）
进队成功之后，执行notEmpty.signal()唤起被阻塞的出队线程
出队的源码类似。ArrayBlockingQueue 队列我们可以在创建线程池时进行使用。

new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(2));

PS：在进行某项业务存储操作时，建议采用offer进行添加，可及时获取boolean进行判断，如用put要考虑阻塞情况（队列的出队操作慢于进队操作），资源占用。

3、SynchronousQueue

SynchronousQueue，实际上它不是一个真正的队列，因为它不会为队列中元素维护存储空间。与其他队列不同的是，它维护一组线程，这些线程在等待着把元素加入或移出队列。

package com.example.rabbitmq.test.nio;

import java.util.concurrent.SynchronousQueue;

public class SynchronousQueueDemo {

    public static void main(String[] args) {
        SynchronousQueue<Integer> synchronousQueue = new SynchronousQueue<>();
        new Thread(() -> {
            try {
                System.out.println("入："+1);
                synchronousQueue.put(1);
                Thread.sleep(3000);
                synchronousQueue.put(2);
                System.out.println("入："+2);
                Thread.sleep(3000);
                synchronousQueue.put(3);
                System.out.println("入："+3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() -> {
            try {
                Integer val = synchronousQueue.take();
                System.out.println("出:"+val);
                Integer val2 = synchronousQueue.take();
                System.out.println("出:"+val2);
                Integer val3 = synchronousQueue.take();
                System.out.println("出:"+val3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

4、阻塞队列的使用场景

• 生产者消费者模式
• 线程池
• 消息中间件