JDK Concurrent包组件概解（5） - BlockingQueue

目录

非阻塞队列

阻塞队列BlockingQueue

ArrayBlockingQueue

LinkedBlockingQueue

SynchronousQueue

PriorityBlockingQueue

DelayQueue

测试

---

// java.util
public interface Queue<E> extends Collection<E> {
   // 继承自Collection，当Queue的元素已经到达限制数目时会抛出IllegalStateException("Queue full")异常  AbstractQueue#add
    boolean add(E e);
   // 仅仅定位于应用在有界Queue的情况下，当Queue已经装满时，offer会返回false
    boolean offer(E e);
   // 除并返回Queue中的头元素. 当Queue为空时抛出NoSuchElementException异常
    E remove();
   // 除并返回Queue中的头元素. 当Queue为空时返回null
    E poll();
    // 返回但不删除Queue中的头元素. 当Queue为空时抛出NoSuchElementException异常
    E element();
   // 返回但不删除Queue中的头元素.当Queue为空时返回null
    E peek();
}

Queue接口与List、Set同一级别，都是继承了Collection接口。通常不允许插入null（会校验并抛出NullPointerException），只有LinkedList例外(它实现了Deque接口)。

不要与poll和peek方法返回的null值混淆，即使在允许null的实现类中，也不应该将null插入到Queue中，因为null也用作poll方法的一个特殊返回值，表明队列不包含元素。

非阻塞队列

1. ArrayDeque数组双端队列 。Deque即双端队列， 具有队列和栈的性质的数据结构。双端队列中的元素可以从两端弹出或添入，其默认新增在队尾 addLast，删除在队首 pollFirst。
2. ConcurrentLinkedQueue 基于链表的并发队列。 使用Unsafe的CAS方式来实现非阻塞式的线程安全。
3. PriorityQueue优先级队列。与PriorityBlockingQueue的区别是不使用ReentrantLock，所以不支持并发。使用数组保存元素，出队在首位；出队和入队操作时都会进行堆排序，保证队列元素次序。在构造函数里可以指定比较方式Comparator，默认为空；若不指定，则元素需要实现接口Comparable。

阻塞队列BlockingQueue

在它的实现类里，通常使用java.util.concurrent.locks.ReentrantLock来控制生产和消费的并发，所以支持在多线程环境下使用。

1. poll(long timeout, TimeUnit unit)   移除并返回队列头部的元素。 如果队列为空，不超过指定时长的阻塞等待。
2. take()  移除并返回队列头部的元素。如果队列为空，则阻塞等待直到有可取的对象。

 Lock下的Condition#await()/#signal()/#signalAll()类似于synchronized 下的 Object#wait()/#notify()/#notifyAll()。Condition 提供了在获取到锁权限的情况下，可主动释放锁资源并在该上下文（代码执行过程片段）中被唤醒执行的能力。

ArrayBlockingQueue

 不可变数组存储对象 , 初始化时需要指定容量大小，理论上最大不超过Integer.MAX_VALUE。

内部使用

• 一把ReentrantLock的不同Condition来控制来控制生产和消费的并发。
• takeIndex 、putIndex 来控制出队和入队时数组下标， 环状数组。(都是按顺序 ++，如果等于items.length则置为0)
• 元素实时计数器 count

    /** The queued items */
    final Object[] items; // 不可变的数组, 容量在初始化时就确定了
    /** items index for next take, poll, peek or remove */
    int takeIndex; // 出队下标
    /** items index for next put, offer, or add */
    int putIndex; // 入队下标
    /** Number of elements in the queue */
    int count; // 元素个数计数
    /** Main lock guarding all access */
    final ReentrantLock lock; // 共用一把锁
    /** Condition for waiting takes */
    private final Condition notEmpty; // 标识可以出队
    /** Condition for waiting puts */
    private final Condition notFull; // 标识可以入队

    public ArrayBlockingQueue(int capacity, boolean fair) {
        if (capacity <= 0)   throw new IllegalArgumentException();
        this.items = new Object[capacity];
        lock = new ReentrantLock(fair);
        notEmpty = lock.newCondition();
        notFull =  lock.newCondition();
    }

• notEmpty ： 标识当前队列非空，可消费。
• notFull  ：    标识当前队列没满，可以生产。 

#take出队时：

1.  先获取ReentrantLock锁权限；
2. 当队列为空(count == 0)，则 notEmpty#await()；否则：用takeIndex控制出队时数组下标(环状： if takeIndex==items.length，则 takeIndex=0)，成功后唤醒一个生产者 notFull#signal()；

#put入队时：

1. 先获取ReentrantLock锁权限；
2. 当队列已满(count == items.length)，则notFull#await()；否则：用putIndex控制入队时数组下标(环状： if  putIndex==items.length，则 putIndex=0)，成功后唤醒一个消费者 notEmpty#signal()；

相当于：生产者和消费者竞争同一把锁， 1次成功出队后会唤醒1次挂起的入队，1次入队成功后又会唤醒1次挂起的出队。 全局保证FIFO。

LinkedBlockingQueue

基于单向链表 ,  默认容量Integer.MAX_VALUE。  队尾添入，队首移出

生产者与消费者分别有独立的锁ReentrantLock、Condition; 同时计数器是支持原子并发的 AtomicInteger ！

    /** The capacity bound, or Integer.MAX_VALUE if none */
    private final int capacity; // 容量
    /** Current number of elements */
    private final AtomicInteger count = new AtomicInteger(); // 节点计数， 支持并发原子
    /**  Head of linked list. Invariant: head.item == null */
    transient Node<E> head; // 队首
    /** Tail of linked list.  Invariant: last.next == null */
    private transient Node<E> last; // 队尾
    /** Lock held by take, poll, etc */
    private final ReentrantLock takeLock = new ReentrantLock(); // 出队锁
    /** Wait queue for waiting takes */
    private final Condition notEmpty = takeLock.newCondition();
    /** Lock held by put, offer, etc */
    private final ReentrantLock putLock = new ReentrantLock(); // 入队锁
    /** Wait queue for waiting puts */
    private final Condition notFull = putLock.newCondition();

    public void put(E e) throws InterruptedException {
        if (e == null) throw new NullPointerException();
        int c = -1;
        Node<E> node = new Node<E>(e);
        final ReentrantLock putLock = this.putLock;
        final AtomicInteger count = this.count;
        putLock.lockInterruptibly();
        try {
            while (count.get() == capacity) {
                notFull.await();
            }
            enqueue(node); //   Links node at end of queue.
            c = count.getAndIncrement();
            if (c + 1 < capacity)
                notFull.signal();
        } finally {
            putLock.unlock();
        }
        if (c == 0)
// 因为count的值是getAndIncrement(),count是未入队之前的值; enqueue(node)已经入队了, 所以这里要唤醒一个消费者
            signalNotEmpty(); 
    }

    public E take() throws InterruptedException {
        E x;
        int c = -1;
        final AtomicInteger count = this.count;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lockInterruptibly();
        try {
            while (count.get() == 0) {
                notEmpty.await();
            }
            x = dequeue(); // Removes a node from head of queue.
            c = count.getAndDecrement();
            if (c > 1)
                notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)
// 因为count的值是getAndIncrement(), 是未出队之前的值; dequeue()已经出队了, 所以这里要唤醒一个生产者。
            signalNotFull();
        return x;
    }
    private void signalNotEmpty() {
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lock();
        try {
            notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
    }
    private void signalNotFull() {
        final ReentrantLock putLock = this.putLock;
        putLock.lock();
        try {
            notFull.signal();
        } finally {
            putLock.unlock();
        }
    }

• #take出队时：
  1. 先拿takeLock的锁权限；
  2. 如果队列为空则notEmpty.await()挂起；否则：弹出head队首位置，如果弹出之前的节点数量count大于1，则唤醒下一个消费者notEmpty.signal()；
  3. 随后释放takeLock权限；
  4. 如果count等于容量capacity，此时有概率所有生产者都处于挂起状态，则拿到putLock锁权限去唤醒notFull.signal()生产者可以开始生产了。
• #put入队时：
  1. 先拿putLock的锁权限； 
  2. 如果队列已满则notFull.await()挂起； 否则：链接新Node到last队尾，如果入队之前的节点数量count小于容量capacity -1，则唤醒下一个生产者notFull.signal()；
  3. 随后释放putLock权限;
  4. 如果count等于0，此时有概率所有的消费者都处于挂起状态，则拿到takeLock锁权限去唤醒消费者notEmpty.signal() 可以开始消费了。

LinkedBlockingDeque 则基于双向链表的双端阻塞队列，使用同一个ReentrantLock的不同Condition控制并发。

SynchronousQueue

并发同步阻塞队列，没有所谓的容量。消费者与生产者只有在两种类型的操作一一匹配后才能正常传递数据。当使用阻塞式方法#put、#take时，将该线程阻塞并维护在等待链上。

见： SynchronousQueue#put -> TransferStack(公平FIFO：TransferQueue)的 #transfer和 #awaitFulfill 方法具体逻辑。

PriorityBlockingQueue

带优先级排序的阻塞队列 ，可变数组存储，默认容量 11 ，最大不超过Integer.MAX_VALUE - 8。 只有一把ReentrantLock！

​​​​​​​newCap = oldCap + ((oldCap < 64) ?  (oldCap + 2) :  (oldCap >> 1));  // 容量小时增长快（>100%），容量大增长慢（50%）

依据构造函数所指定的Comparator#compare（优先） 或 对象实现接口方法Comparable#compareTo来决定堆排序。

它和前文JDK Concurrent包组件概解（4）- ScheduledThreadPoolExecutor & Timer讲述的这两个调度器使用的任务存储队列是类似的处理逻辑： 堆排序后只保证每一个子树的root是该树内全局最小，但队列内所有元素不严格有序。

DelayQueue<E extends Delayed>

无界带延时的阻塞队列, 对象只能在到期时才能从队列中取走，队头对象最快到期。

  也是一把ReentrantLock！内部使用PriorityQueue存储，null元素入队抛出异常NullPointerException。

元素需要实现接口 java.util.concurrent.Delayed （extends Comparable<Delayed>）：

1. 接口方法java.util.concurrent.Delayed#getDelay： 标识各个元素的延时时长 ，用来延时出队。
2. 接口方法Comparable<Delayed>#compareTo是比较Delayed#getDelay的值，延时最小的元素在队首； 它是PriorityQueue队列内元素堆排序的依据。

出队方法#take()的实现里：

若延时(Delayed#getDelay)大于0 ，则释放锁权限等待该延时：Condition.awaitNanos(Delayed.getDelay(TimeUnit.NANOSECONDS))。为了保证并发安全，由全局变量“Thread leader”来绑定获取到锁权限的线程，这样即使它挂起了依然可以保证单线程。

与前文 JDK Concurrent包组件概解（4）- ScheduledThreadPoolExecutor & Timer里讲到ScheduledThreadPoolExecutor使用的存储队列DelayedWorkQueue原理类似。

测试

import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.PriorityBlockingQueue;

public class PriorityBlockingQueueTest {

	public static void main(String[] args) {
		PriorityBlockingQueue<Integer> queue = new PriorityBlockingQueue<Integer>();
		for (int i = 0; i < 15; i++) {
			queue.add(new Random().nextInt(20));
			System.out.println(Arrays.toString(queue.toArray()));
		}
	}
}

// result
[19]
[2, 19]
[2, 19, 7]
[2, 14, 7, 19]
[2, 10, 7, 19, 14]
[2, 10, 7, 19, 14, 19]
[2, 10, 7, 19, 14, 19, 16]
[2, 3, 7, 10, 14, 19, 16, 19]
[2, 3, 7, 10, 14, 19, 16, 19, 16]
[2, 3, 7, 10, 13, 19, 16, 19, 16, 14]
[2, 3, 7, 10, 3, 19, 16, 19, 16, 14, 13]
[2, 3, 2, 10, 3, 7, 16, 19, 16, 14, 13, 19]
[2, 3, 2, 10, 3, 2, 16, 19, 16, 14, 13, 19, 7]
[2, 3, 2, 10, 3, 2, 10, 19, 16, 14, 13, 19, 7, 16]
[2, 3, 2, 10, 3, 2, 7, 19, 16, 14, 13, 19, 7, 16, 10]

从上文可以看到：

1. 整个队列里的元素并不是全局有序。
2. 将它看做一颗树，那每一个子树root一定是最小的。