Java从JDK5开始在并发包内引入了BlockingQueue（阻塞队列），它除了提供队列的FIFO功能之外，还提供了额外的功能，例如：

1. 当获取队列内容时发现队列为空，则等待其变为非空。
2. 当往队列存储内容时如果队列已满，则等待其他线程获取队列内容其变得可用。

从源码来看，BlockingQueue主要提供了读和存两组方法：

//往队列尾部添加元素，如果成功返回true，否则抛错
boolean add(E e);
//往队列尾部添加元素，如果成功返回true，否则返回false
boolean offer(E e);
//往队列尾部添加元素，如果成功返回true，否则在指定时间内等待队列变得可用，如果队列仍不可用返回false
boolean offer(E e, long timeout, TimeUnit unit)
//往队列尾部添加元素，如果成功则返回，否则一直等待队列变得可用
void put(E e)

//获取并删除队列头部元素，如果队列为空则一直等待
E take()
//获取并删除队列头部元素，如果成功返回头部元素，否则返回null
E poll();
//获取并删除队列头部元素，如果成功返回头部元素，否则在指定时间内等待队列变得可用返回并返回头部元素，如果队列仍不可用返回null
E poll(long timeout, TimeUnit unit)
//删除队列中的一个元素并返回true（通过equals判断，如果有多个元素相等，只删除一个），没有删除掉元素返回false
boolean remove(Object o);

BlockingQueue继承了Queue接口，同时在并发包内也提供以下几个实现类，本篇文章主要通过ArrayBlockingQueue和LinkedBlockingQueue这两个实现类来介绍BlockingQueue的功能已经其背后的原理。

• ArrayBlockQueue
• LinkedBlockingQueue
• PriorityBlockingQueue
• SynchronousQueue
• DelayQueue等

ArrayBlockingQueue

从名字我们可以看出ArrayBlockingQueue是一个基于数组的BlockingQueue，并且数组都是有固定长度的。数组本身是读操作比较有优势，增加、删除操作大部分情况下是性能比较低的，下面我们来看下ArrayBlockingQueue是如何巧妙使用数组的。

从源码可以看到，它有以下几个成员变量：

//用来存储队列的元素
final Object[] items;
//表示下一次读取和移除操作（take、poll等）对应的数组索引
int takeIndex;
//表示下一次添加操作（offer，put等）对应的数组索引
int putIndex;
//实际队列中元素的个数
int count;
//用来控制并发操作的可重入锁
final ReentrantLock lock;
//take等操作用来等待的Condition对象
private final Condition notEmpty;
//put等操作用来等待的Condition对象
private final Condition notFull;

相关的成员变量反应到结构图如下，ArrayBlockingQueue的内部数组items是在构造函数就创建好的，并且长度是固定不变的，它通过改变takeIndex、putIndex和count来表示队列中的状态。比如下图中队列内元素数量count为4（灰色部分）。

那么ArrayBlockingQueue是如何支持多线程同时操作的呢？我们通过源码可以看到它内部是通过ReentrantLock来实现的（ReentrantLock和AQS的介绍可以参考文末链接）。

public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == 0)
                notEmpty.await();
            return dequeue();
        } finally {
            lock.unlock();
        }
}

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();
        }
}

ConditionObject

上面的两个ArrayBlockingQueue方法（put和take），它们都用到了AQS中内部类ConditionObject的功能（notEmpty.await()和notFull.await()）。

每个ConditionObject内部都维护着一个单向链表，调用await方法会使当前线程加入到这个单向链表中并且使当前线程休眠，调用signal方法会将ConditionObject内单向链表的头结点移动到AQS中并唤醒它。

ArrayBlockingQueue例子

下面我们来看一个简单的ArrayBlockingQueue相关例子，我们启动了两个线程，消费者线程不停的去队列里面获取元素，队列为空的时候就休眠等待，而生产者线程每隔一秒钟往队列里面插入一个元素。

public static void main(String[] args) {
        DateFormat df = new SimpleDateFormat("HH:mm:ss---");
        BlockingQueue<Integer> bq = new ArrayBlockingQueue<>(10);
        Thread consumerThread = new Thread() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Integer value = bq.take();
                        System.out.println(df.format(new Date()) + "get " + value + " from queue");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        consumerThread.start();
        
        Thread producerThread = new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    try {
                        bq.put(i);
                        System.out.println(df.format(new Date()) + "put " + i + " to queue");
                        Thread.sleep(1000);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        producerThread.start();
}

程序打印结果如下，和我们预期的一样：

12:54:24---put 0 to queue
12:54:24---get 0 from queue
12:54:25---put 1 to queue
12:54:25---get 1 from queue
12:54:26---put 2 to queue
12:54:26---get 2 from queue
12:54:27---put 3 to queue
12:54:27---get 3 from queue
12:54:28---get 4 from queue
12:54:28---put 4 to queue

LinkedBlockingQueue

LinkedBlockingQueue是一种基于链表BlockingQueue，从功能上来讲，它和ArrayBlockingQueue是一样的，但是底层原理和实现不同，下面我们来看下它和ArrayBlockingQueue的对比。

首先我们看下LinkedBlockingQueue的主要成员变量：

// 阻塞队列的容量，默认是Integer.MAX_VALUE
private final int capacity;
// 当前队列中元素的数量， AtomicInteger相关介绍可以参考文末链接
private final AtomicInteger count = new AtomicInteger();
//链表头结点
transient Node<E> head;
//链表尾节点
private transient Node<E> last;
//获取队列头部元素时使用的可重入锁
private final ReentrantLock takeLock = new ReentrantLock();
//take等操作用来等待的Condition对象
private final Condition notEmpty = takeLock.newCondition();
//往队列尾部添加元素时使用的可重入锁
private final ReentrantLock putLock = new ReentrantLock();
//put等操作用来等待的Condition对象
private final Condition notFull = putLock.newCondition();

从成员变量我们发现，和ArrayBlockingQueue相比，除了内部的数据结构从数组变成了链表，支持多线程操作的可重入锁也分成了两个，一个控制获取（并移除）首元素操作，另一个控制添加操作，这样当同时有两种操作的时候可以得到更好的性能提升。

那么问题来了，为什么ArrayBlockingQueue不使用两把锁呢？这样不是也可以获取更好的吞吐量吗？其主要原因还是ArrayBlockingQueue内的数组是循环使用的，两种操作都操作在同一个数组上并且还有可能操作到同一个元素上，而链表则是随时移除老节点和添加新的节点。

Demo代码位置

src/main/java/net/weichitech/juc/ArrayBlockingQueueTest.java · 小西学编程/java-learning - Gitee.com

相关文章

JAVA并发之ReentrantLock原理解析

JAVA并发之AtomicInteger原理分析