深度剖析！Java BlockingQueue 使用原理全揭秘
一、引言
在 Java 多线程编程的世界里，线程间的通信与协作是一个核心问题。当多个线程需要共享数据时，如何确保数据的安全传输和高效处理成为了开发者们必须面对的挑战。BlockingQueue 作为 Java 并发包 java.util.concurrent 中的重要成员，为我们提供了一种强大而便捷的解决方案。
BlockingQueue 是一个接口，它继承自 Queue 接口，代表了一个支持阻塞操作的队列。阻塞操作意味着当队列满时，插入元素的线程会被阻塞，直到队列有空间可用；当队列空时，获取元素的线程会被阻塞，直到队列中有元素可用。这种特性使得 BlockingQueue 非常适合用于生产者 - 消费者模式，在该模式中，生产者线程负责向队列中添加元素，消费者线程负责从队列中取出元素，两者通过队列进行数据的传递和协作。
本文将深入剖析 BlockingQueue 的使用原理，从源码层面进行详细解读。我们将逐步分析 BlockingQueue 接口的定义、常见实现类（如 ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue 等）的构造方法、核心操作方法（如插入、删除、查找）以及并发控制机制，通过大量的源码和详细的注释，帮助读者全面理解 BlockingQueue 的工作原理。同时，我们还将探讨其性能特点、适用场景以及与其他队列类的比较。通过阅读本文，你将对 BlockingQueue 有一个深入而透彻的认识，能够在实际项目中更加合理地运用它。
二、BlockingQueue 概述
2.1 基本概念
BlockingQueue 是 Java 并发包中定义的一个接口，它代表了一个支持阻塞操作的队列。阻塞操作主要包括两种情况：
- 插入操作：当队列已满时，尝试向队列中插入元素的线程会被阻塞，直到队列有空间可用。
- 移除操作：当队列为空时，尝试从队列中移除元素的线程会被阻塞，直到队列中有元素可用。
BlockingQueue 接口定义了一系列的方法，用于插入、移除和检查队列中的元素。这些方法可以分为以下几类：
- 插入方法：
add(E e)、offer(E e)、put(E e)、offer(E e, long timeout, TimeUnit unit)。 - 移除方法：
remove()、poll()、take()、poll(long timeout, TimeUnit unit)。 - 检查方法：
element()、peek()。
2.2 特点
- 线程安全：
BlockingQueue保证了在多线程环境下对队列的操作是线程安全的，多个线程可以同时对队列进行读写操作，而无需额外的同步机制。 - 阻塞特性：支持阻塞操作，使得生产者 - 消费者模式的实现更加简单和高效。
- 有界和无界：
BlockingQueue可以是有界的（即队列有最大容量限制），也可以是无界的（即队列容量没有限制）。
2.3 应用场景
由于 BlockingQueue 具有线程安全和阻塞特性，它适用于以下场景：
- 生产者 - 消费者模式：这是
BlockingQueue最常见的应用场景。生产者线程负责向队列中添加元素，消费者线程负责从队列中取出元素，两者通过队列进行数据的传递和协作。 - 线程池：线程池通常使用
BlockingQueue来存储待执行的任务。当线程池中的线程数量达到最大值时，新的任务会被放入队列中等待执行。 - 异步处理：在异步处理场景中，
BlockingQueue可以作为一个缓冲区，用于存储待处理的任务或数据。
三、BlockingQueue 接口源码分析
// java.util.concurrent.BlockingQueue 接口的定义，继承自 Queue 接口
public interface BlockingQueue<E> extends Queue<E> {
// 向队列中插入指定元素，如果队列已满则抛出 IllegalStateException 异常
boolean add(E e);
// 向队列中插入指定元素，如果队列已满则返回 false
boolean offer(E e);
// 向队列中插入指定元素，如果队列已满则阻塞当前线程，直到队列有空间可用
void put(E e) throws InterruptedException;
// 向队列中插入指定元素，如果队列已满则等待指定的时间，如果在指定时间内队列有空间可用则插入元素并返回 true，否则返回 false
boolean offer(E e, long timeout, TimeUnit unit)
throws InterruptedException;
// 从队列中移除并返回队首元素，如果队列为空则阻塞当前线程，直到队列中有元素可用
E take() throws InterruptedException;
// 从队列中移除并返回队首元素，如果队列为空则等待指定的时间，如果在指定时间内队列中有元素可用则移除并返回该元素，否则返回 null
E poll(long timeout, TimeUnit unit)
throws InterruptedException;
// 返回队列中剩余的容量
int remainingCapacity();
// 从队列中移除指定元素的所有实例，如果队列中包含该元素则返回 true，否则返回 false
boolean remove(Object o);
// 判断队列中是否包含指定元素，如果包含则返回 true，否则返回 false
public boolean contains(Object o);
// 将队列中的所有元素转移到指定的集合中，返回转移的元素数量
int drainTo(Collection<? super E> c);
// 将队列中最多指定数量的元素转移到指定的集合中，返回转移的元素数量
int drainTo(Collection<? super E> c, int maxElements);
}
从上述代码可以看出，BlockingQueue 接口继承自 Queue 接口，它定义了一系列的方法，用于插入、移除和检查队列中的元素。这些方法可以分为以下几类：
- 插入方法：
add(E e)、offer(E e)、put(E e)、offer(E e, long timeout, TimeUnit unit)。这些方法的区别在于当队列已满时的处理方式不同。add(E e)方法会抛出IllegalStateException异常，offer(E e)方法会返回false，put(E e)方法会阻塞当前线程，offer(E e, long timeout, TimeUnit unit)方法会等待指定的时间。 - 移除方法：
remove()、poll()、take()、poll(long timeout, TimeUnit unit)。这些方法的区别在于当队列为空时的处理方式不同。remove()方法会抛出NoSuchElementException异常，poll()方法会返回null，take()方法会阻塞当前线程，poll(long timeout, TimeUnit unit)方法会等待指定的时间。 - 检查方法：
element()、peek()。这些方法用于检查队首元素，但不会移除元素。element()方法在队列为空时会抛出NoSuchElementException异常，peek()方法在队列为空时会返回null。 - 其他方法：
remainingCapacity()方法用于返回队列中剩余的容量，remove(Object o)方法用于从队列中移除指定元素的所有实例，contains(Object o)方法用于判断队列中是否包含指定元素，drainTo(Collection<? super E> c)和drainTo(Collection<? super E> c, int maxElements)方法用于将队列中的元素转移到指定的集合中。
四、常见实现类源码分析
4.1 ArrayBlockingQueue
4.1.1 类的定义和成员变量
// java.util.concurrent.ArrayBlockingQueue 类的定义，继承自 AbstractQueue 类并实现了 BlockingQueue 接口
public class ArrayBlockingQueue<E> extends AbstractQueue<E>
implements BlockingQueue<E>, java.io.Serializable {
// 用于序列化和反序列化的版本号
private static final long serialVersionUID = -817911632652898426L;
// 用于存储队列元素的数组
final Object[] items;
// 队首元素的索引
int takeIndex;
// 队尾元素的下一个索引
int putIndex;
// 队列中元素的数量
int count;
// 用于保护队列操作的可重入锁
final ReentrantLock lock;
// 用于等待元素可用的条件对象
private final Condition notEmpty;
// 用于等待队列有空间可用的条件对象
private final Condition notFull;
// 迭代器，用于遍历队列中的元素
transient Itrs itrs = null;
// 构造方法，创建一个具有指定容量和公平性的 ArrayBlockingQueue 实例
public ArrayBlockingQueue(int capacity, boolean fair) {
// 检查容量是否为正数，如果不是则抛出 IllegalArgumentException 异常
if (capacity <= 0)
throw new IllegalArgumentException();
// 初始化存储元素的数组
this.items = new Object[capacity];
// 初始化可重入锁，根据公平性参数决定是否使用公平锁
lock = new ReentrantLock(fair);
// 初始化等待元素可用的条件对象
notEmpty = lock.newCondition();
// 初始化等待队列有空间可用的条件对象
notFull = lock.newCondition();
}
// 构造方法，创建一个具有指定容量的 ArrayBlockingQueue 实例，使用非公平锁
public ArrayBlockingQueue(int capacity) {
// 调用另一个构造方法，使用非公平锁
this(capacity, false);
}
// 构造方法，创建一个具有指定容量和公平性的 ArrayBlockingQueue 实例，并将指定集合中的元素添加到队列中
public ArrayBlockingQueue(int capacity, boolean fair,
Collection<? extends E> c) {
// 调用另一个构造方法，初始化存储元素的数组、可重入锁和条件对象
this(capacity, fair);
final ReentrantLock lock = this.lock;
// 获取锁
lock.lock(); // Lock only for visibility, not mutual exclusion
try {
int i = 0;
try {
// 将指定集合中的元素添加到队列中
for (E e : c) {
// 检查元素是否为 null，如果为 null 则抛出 NullPointerException 异常
checkNotNull(e);
// 将元素添加到队列中
items[i++] = e;
}
} catch (ArrayIndexOutOfBoundsException ex) {
// 如果集合中的元素数量超过队列容量，则抛出 IllegalArgumentException 异常
throw new IllegalArgumentException();
}
// 更新队列中元素的数量
count = i;
// 更新队尾元素的下一个索引
putIndex = (i == capacity) ? 0 : i;
} finally {
// 释放锁
lock.unlock();
}
}
}
从上述代码可以看出，ArrayBlockingQueue 类继承自 AbstractQueue 类并实现了 BlockingQueue 接口，它使用一个数组来存储队列中的元素。items 数组用于存储元素，takeIndex 表示队首元素的索引，putIndex 表示队尾元素的下一个索引，count 表示队列中元素的数量。lock 是一个可重入锁，用于保护队列的操作，notEmpty 和 notFull 是两个条件对象，分别用于等待元素可用和队列有空间可用。
构造方法提供了多种初始化方式，包括创建一个具有指定容量和公平性的 ArrayBlockingQueue 实例、创建一个具有指定容量的 ArrayBlockingQueue 实例（使用非公平锁）以及创建一个具有指定容量和公平性的 ArrayBlockingQueue 实例，并将指定集合中的元素添加到队列中。
4.1.2 核心操作方法
插入操作（put 方法）
// 向队列中插入指定元素，如果队列已满则阻塞当前线程，直到队列有空间可用
public void put(E e) throws InterruptedException {
// 检查元素是否为 null，如果为 null 则抛出 NullPointerException 异常
checkNotNull(e);
final ReentrantLock lock = this.lock;
// 获取锁，允许线程在等待过程中被中断
lock.lockInterruptibly();
try {
// 当队列已满时，当前线程进入等待状态
while (count == items.length)
notFull.await();
// 调用 enqueue 方法将元素插入到队列中
enqueue(e);
} finally {
// 释放锁
lock.unlock();
}
}
// 将元素插入到队列中的方法
private void enqueue(E x) {
// assert lock.getHoldCount() == 1;
// assert items[putIndex] == null;
final Object[] items = this.items;
// 将元素插入到队尾
items[putIndex] = x;
// 更新队尾元素的下一个索引，如果达到数组末尾则回到数组开头
if (++putIndex == items.length)
putIndex = 0;
// 增加队列中元素的数量
count++;
// 唤醒等待元素可用的线程
notEmpty.signal();
}
put 方法是向队列中插入指定元素的方法，如果队列已满则阻塞当前线程，直到队列有空间可用。它首先检查元素是否为 null，然后获取锁，允许线程在等待过程中被中断。接着，当队列已满时，当前线程进入等待状态，直到队列有空间可用。最后，调用 enqueue 方法将元素插入到队列中，并释放锁。
enqueue 方法是将元素插入到队列中的具体实现方法。它将元素插入到队尾，更新队尾元素的下一个索引，如果达到数组末尾则回到数组开头。然后增加队列中元素的数量，并唤醒等待元素可用的线程。
移除操作（take 方法）
// 从队列中移除并返回队首元素，如果队列为空则阻塞当前线程，直到队列中有元素可用
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
// 获取锁，允许线程在等待过程中被中断
lock.lockInterruptibly();
try {
// 当队列为空时，当前线程进入等待状态
while (count == 0)
notEmpty.await();
// 调用 dequeue 方法从队列中移除并返回队首元素
return dequeue();
} finally {
// 释放锁
lock.unlock();
}
}
// 从队列中移除并返回队首元素的方法
private E dequeue() {
// assert lock.getHoldCount() == 1;
// assert items[takeIndex] != null;
final Object[] items = this.items;
@SuppressWarnings("unchecked")
// 获取队首元素
E x = (E) items[takeIndex];
// 将队首元素置为 null
items[takeIndex] = null;
// 更新队首元素的索引，如果达到数组末尾则回到数组开头
if (++takeIndex == items.length)
takeIndex = 0;
// 减少队列中元素的数量
count--;
if (itrs != null)
// 更新迭代器
itrs.elementDequeued();
// 唤醒等待队列有空间可用的线程
notFull.signal();
return x;
}
take 方法是从队列中移除并返回队首元素的方法，如果队列为空则阻塞当前线程，直到队列中有元素可用。它首先获取锁，允许线程在等待过程中被中断。接着，当队列为空时，当前线程进入等待状态，直到队列中有元素可用。最后，调用 dequeue 方法从队列中移除并返回队首元素，并释放锁。
dequeue 方法是从队列中移除并返回队首元素的具体实现方法。它获取队首元素，将队首元素置为 null，更新队首元素的索引，如果达到数组末尾则回到数组开头。然后减少队列中元素的数量，更新迭代器，并唤醒等待队列有空间可用的线程。
检查操作（peek 方法）
// 查看队首元素，但不移除，如果队列为空则返回 null
public E peek() {
final ReentrantLock lock = this.lock;
// 获取锁
lock.lock();
try {
// 返回队首元素，如果队列为空则返回 null
return itemAt(takeIndex); // null when queue is empty
} finally {
// 释放锁
lock.unlock();
}
}
// 获取指定索引位置的元素的方法
final E itemAt(int i) {
return (E) items[i];
}
peek 方法是查看队首元素，但不移除，如果队列为空则返回 null。它首先获取锁，然后调用 itemAt 方法获取队首元素，并返回该元素。最后释放锁。
4.2 LinkedBlockingQueue
4.2.1 类的定义和成员变量
// java.util.concurrent.LinkedBlockingQueue 类的定义，继承自 AbstractQueue 类并实现了 BlockingQueue 接口
public class LinkedBlockingQueue<E> extends AbstractQueue<E>
implements BlockingQueue<E>, java.io.Serializable {
// 用于序列化和反序列化的版本号
private static final long serialVersionUID = -6903933977591709194L;
// 节点类，用于存储队列中的元素
static class Node<E> {
// 元素
E item;
// 指向下一个节点的引用
Node<E> next;
// 构造方法，初始化节点的元素
Node(E x) { item = x; }
}
// 队列的容量，如果为 Integer.MAX_VALUE 则表示无界队列
private final int capacity;
// 队列中元素的数量
private final AtomicInteger count = new AtomicInteger();
// 队首节点
transient Node<E> head;
// 队尾节点
private transient Node<E> last;
// 用于出队操作的锁
private final ReentrantLock takeLock = new ReentrantLock();
// 用于等待元素可用的条件对象
private final Condition notEmpty = takeLock.newCondition();
// 用于入队操作的锁
private final ReentrantLock putLock = new ReentrantLock();
// 用于等待队列有空间可用的条件对象
private final Condition notFull = putLock.newCondition();
// 构造方法，创建一个具有指定容量的 LinkedBlockingQueue 实例
public LinkedBlockingQueue(int capacity) {
// 检查容量是否为正数，如果不是则抛出 IllegalArgumentException 异常
if (capacity <= 0) throw new IllegalArgumentException();
// 初始化队列的容量
this.capacity = capacity;
// 初始化队首节点和队尾节点，初始时队首节点和队尾节点都指向一个空节点
last = head = new Node<E>(null);
}
// 构造方法，创建一个无界的 LinkedBlockingQueue 实例
public LinkedBlockingQueue() {
// 调用另一个构造方法，将容量设置为 Integer.MAX_VALUE
this(Integer.MAX_VALUE);
}
// 构造方法，创建一个具有指定容量的 LinkedBlockingQueue 实例，并将指定集合中的元素添加到队列中
public LinkedBlockingQueue(Collection<? extends E> c) {
// 调用另一个构造方法，将容量设置为 Integer.MAX_VALUE
this(Integer.MAX_VALUE);
final ReentrantLock putLock = this.putLock;
// 获取入队操作的锁
putLock.lock(); // Never contended, but necessary for visibility
try {
int n = 0;
for (E e : c) {
// 检查元素是否为 null，如果为 null 则抛出 NullPointerException 异常
if (e == null)
throw new NullPointerException();
// 如果队列已满，则抛出 IllegalStateException 异常
if (n == capacity)
throw new IllegalStateException("Queue full");
// 调用 enqueue 方法将元素插入到队列中
enqueue(new Node<E>(e));
// 增加队列中元素的数量
++n;
}
// 更新队列中元素的数量
count.set(n);
} finally {
// 释放入队操作的锁
putLock.unlock();
}
}
}
从上述代码可以看出，LinkedBlockingQueue 类继承自 AbstractQueue 类并实现了 BlockingQueue 接口，它使用一个链表来存储队列中的元素。Node 类是链表中的节点类，用于存储元素和指向下一个节点的引用。capacity 表示队列的容量，如果为 Integer.MAX_VALUE 则表示无界队列。count 是一个 AtomicInteger 类型的变量，用于记录队列中元素的数量。head 表示队首节点，last 表示队尾节点。takeLock 和 putLock 是两个可重入锁，分别用于出队操作和入队操作，notEmpty 和 notFull 是两个条件对象，分别用于等待元素可用和队列有空间可用。
构造方法提供了多种初始化方式，包括创建一个具有指定容量的 LinkedBlockingQueue 实例、创建一个无界的 LinkedBlockingQueue 实例以及创建一个具有指定容量的 LinkedBlockingQueue 实例，并将指定集合中的元素添加到队列中。
4.2.2 核心操作方法
插入操作（put 方法）
// 向队列中插入指定元素，如果队列已满则阻塞当前线程，直到队列有空间可用
public void put(E e) throws InterruptedException {
// 检查元素是否为 null，如果为 null 则抛出 NullPointerException 异常
if (e == null) throw new NullPointerException();
// 为了简化代码，将 -1 作为一个特殊值表示插入失败
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 方法将新节点插入到队列中
enqueue(node);
// 获取插入元素前队列中元素的数量
c = count.getAndIncrement();
// 如果插入元素后队列还有空间，则唤醒等待队列有空间可用的其他线程
if (c + 1 < capacity)
notFull.signal();
} finally {
// 释放入队操作的锁
putLock.unlock();
}
// 如果插入元素前队列为空，则唤醒等待元素可用的线程
if (c == 0)
signalNotEmpty();
}
// 将新节点插入到队列中的方法
private void enqueue(Node<E> node) {
// 将新节点设置为队尾节点的下一个节点
last = last.next = node;
}
// 唤醒等待元素可用的线程的方法
private void signalNotEmpty() {
final ReentrantLock takeLock = this.takeLock;
// 获取出队操作的锁
takeLock.lock();
try {
// 唤醒等待元素可用的线程
notEmpty.signal();
} finally {
// 释放出队操作的锁
takeLock.unlock();
}
}
put 方法是向队列中插入指定元素的方法，如果队列已满则阻塞当前线程，直到队列有空间可用。它首先检查元素是否为 null，然后创建一个新的节点用于存储要插入的元素。接着获取入队操作的锁，允许线程在等待过程中被中断。当队列已满时，当前线程进入等待状态，直到队列有空间可用。然后调用 enqueue 方法将新节点插入到队列中，获取插入元素前队列中元素的数量。如果插入元素后队列还有空间，则唤醒等待队列有空间可用的其他线程。最后释放入队操作的锁，如果插入元素前队列为空，则唤醒等待元素可用的线程。
enqueue 方法是将新节点插入到队列中的具体实现方法，它将新节点设置为队尾节点的下一个节点。
signalNotEmpty 方法是唤醒等待元素可用的线程的方法，它首先获取出队操作的锁，然后唤醒等待元素可用的线程，最后释放出队操作的锁。
移除操作（take 方法）
// 从队列中移除并返回队首元素，如果队列为空则阻塞当前线程，直到队列中有元素可用
public E take() throws InterruptedException {
// 为了简化代码，将 -1 作为一个特殊值表示移除失败
E x;
int c = -1;
final AtomicInteger count = this.count;
final ReentrantLock takeLock = this.takeLock;
// 获取出队操作的锁，允许线程在等待过程中被中断
takeLock.lockInterruptibly();
try {
// 当队列为空时，当前线程进入等待状态
while (count.get() == 0) {
notEmpty.await();
}
// 调用 dequeue 方法从队列中移除并返回队首元素
x = dequeue();
// 获取移除元素前队列中元素的数量
c = count.getAndDecrement();
// 如果移除元素后队列中还有元素，则唤醒等待元素可用的其他线程
if (c > 1)
notEmpty.signal();
} finally {
// 释放出队操作的锁
takeLock.unlock();
}
// 如果移除元素前队列已满，则唤醒等待队列有空间可用的线程
if (c == capacity)
signalNotFull();
return x;
}
// 从队列中移除并返回队首元素的方法
private E dequeue() {
// 记录当前队首节点
Node<E> h = head;
// 获取队首节点的下一个节点，即实际的队首元素所在的节点
Node<E> first = h.next;
// 将当前队首节点的下一个节点指向自身，帮助垃圾回收
h.next = h; // help GC
// 将队首节点更新为实际的队首元素所在的节点
head = first;
// 获取队首元素
E x = first.item;
// 将队首元素置为 null
first.item = null;
return x;
}
// 唤醒等待队列有空间可用的线程的方法
private void signalNotFull() {
final ReentrantLock putLock = this.putLock;
// 获取入队操作的锁
putLock.lock();
try {
// 唤醒等待队列有空间可用的线程
notFull.signal();
} finally {
// 释放入队操作的锁
putLock.unlock();
}
}
take 方法是从队列中移除并返回队首元素的方法，如果队列为空则阻塞当前线程，直到队列中有元素可用。它首先获取出队操作的锁，允许线程在等待过程中被中断。当队列为空时，当前线程进入等待状态，直到队列中有元素可用。然后调用 dequeue 方法从队列中移除并返回队首元素，获取移除元素前队列中元素的数量。如果移除元素后队列中还有元素，则唤醒等待元素可用的其他线程。最后释放出队操作的锁，如果移除元素前队列已满，则唤醒等待队列有空间可用的线程。
dequeue 方法是从队列中移除并返回队首元素的具体实现方法，它记录当前队首节点，获取队首节点的下一个节点，将当前队首节点的下一个节点指向自身，帮助垃圾回收，然后将队首节点更新为实际的队首元素所在的节点，获取队首元素并将其置为 null。
signalNotFull 方法是唤醒等待队列有空间可用的线程的方法，它首先获取入队操作的锁，然后唤醒等待队列有空间可用的线程，最后释放入队操作的锁。
检查操作（peek 方法）
// 查看队首元素，但不移除，如果队列为空则返回 null
public E peek() {
// 如果队列为空，则直接返回 null
if (count.get() == 0)
return null;
final ReentrantLock takeLock = this.takeLock;
// 获取出队操作的锁
takeLock.lock();
try {
// 获取队首节点的下一个节点，即实际的队首元素所在的节点
Node<E> first = head.next;
// 如果实际的队首元素所在的节点为空，则返回 null，否则返回队首元素
return (first == null) ? null : first.item;
} finally {
// 释放出队操作的锁
takeLock.unlock();
}
}
peek 方法是查看队首元素，但不移除，如果队列为空则返回 null。它首先检查队列是否为空，如果为空则直接返回 null。然后获取出队操作的锁，获取队首节点的下一个节点，即实际的队首元素所在的节点。如果实际的队首元素所在的节点为空，则返回 null，否则返回队首元素。最后释放出队操作的锁。
4.3 PriorityBlockingQueue
4.3.1 类的定义和成员变量
// java.util.concurrent.PriorityBlockingQueue 类的定义，继承自 AbstractQueue 类并实现了 BlockingQueue 接口
public class PriorityBlockingQueue<E> extends AbstractQueue<E>
implements BlockingQueue<E>, java.io.Serializable {
// 用于序列化和反序列化的版本号
private static final long serialVersionUID = 5595510919245408276L;
// 默认的初始容量
private static final int DEFAULT_INITIAL_CAPACITY = 11;
// 最大的数组容量
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
// 用于存储队列元素的数组
private transient Object[] queue;
// 队列中元素的数量
private transient int size;
// 比较器，用于对元素进行排序
private transient Comparator<? super E> comparator;
// 用于保护队列操作的可重入锁
private final ReentrantLock lock;
// 用于等待元素可用的条件对象
private final Condition notEmpty;
// 用于实现数组扩容的原子变量
private transient volatile int allocationSpinLock;
// 用于序列化和反序列化的优先队列
private PriorityQueue<E> q;
// 构造方法，创建一个具有默认初始容量的 PriorityBlockingQueue 实例，使用元素的自然顺序进行排序
public PriorityBlockingQueue() {
// 调用另一个构造方法，使用默认初始容量和 null 比较器
this(DEFAULT_INITIAL_CAPACITY, null);
}
// 构造方法，创建一个具有指定初始容量的 PriorityBlockingQueue 实例，使用元素的自然顺序进行排序
public PriorityBlockingQueue(int initialCapacity) {
// 调用另一个构造方法，使用指定初始容量和 null 比较器
this(initialCapacity, null);
}
// 构造方法，创建一个具有指定初始容量和比较器的 PriorityBlockingQueue 实例
public PriorityBlockingQueue(int initialCapacity,
Comparator<? super E> comparator) {
// 检查初始容量是否为正数，如果不是则抛出 IllegalArgumentException 异常
if (initialCapacity < 1)
throw new IllegalArgumentException();
// 初始化存储元素的数组
this.queue = new Object[initialCapacity];
// 初始化比较器
this.comparator = comparator;
// 初始化可重入锁
this.lock = new ReentrantLock();
// 初始化等待元素可用的条件对象
this.notEmpty = lock.newCondition();
// 初始化数组扩容的原子变量
this.allocationSpinLock = 0;
}
// 构造方法，创建一个具有指定集合元素的 PriorityBlockingQueue 实例，使用元素的自然顺序进行排序
public PriorityBlockingQueue(Collection<? extends E> c) {
// 初始化可重入锁
this.lock = new ReentrantLock();
// 初始化等待元素可用的条件对象
this.notEmpty = lock.newCondition();
// 标记是否需要堆化
boolean heapify = true; // true if not known to be in heap order
// 标记是否需要排序
boolean screen = true; // true if must screen for nulls
if (c instanceof SortedSet<?>) {
// 如果集合是 SortedSet 类型，则获取其比较器
SortedSet<? extends E> ss = (SortedSet<? extends E>) c;
this.comparator = (Comparator<? super E>) ss.comparator();
heapify = false;
}
else if (c instanceof PriorityBlockingQueue<?>) {
// 如果集合是 PriorityBlockingQueue 类型，则获取其比较器
PriorityBlockingQueue<? extends E> pq =
(PriorityBlockingQueue<? extends E>) c;
this.comparator = (Comparator<? super E>) pq.comparator();
screen = false;
if (pq.getClass() == PriorityBlockingQueue.class) // exact match
heapify = false;
}
// 将集合中的元素转换为数组
Object[] a = c.toArray();
int n = a.length;
// 如果数组类型不是 Object[]，则将其转换为 Object[] 类型
if (a.getClass() != Object[].class)
a = Arrays.copyOf(a, n, Object[].class);
if (screen && (n == 1 || this.comparator != null)) {
// 检查数组中是否有 null 元素
for (int i = 0; i < n; ++i)
if (a[i] == null)
throw new NullPointerException();
}
// 初始化存储元素的数组
this.queue = a;
// 初始化队列中元素的数量
this.size = n;
if (heapify)
// 如果需要堆化，则进行堆化操作
heapify();
}
}
从上述代码可以看出，PriorityBlockingQueue 类继承自 AbstractQueue 类并实现了 BlockingQueue 接口，它使用一个数组来存储队列中的元素，并使用堆（优先队列）的结构来维护元素的顺序。queue 数组用于存储元素，size 表示队列中元素的数量，comparator 是一个比较器，用于对元素进行排序。lock 是一个可重入锁，用于保护队列的操作，notEmpty 是一个条件对象，用于等待元素可用。allocationSpinLock 是一个原子变量，用于实现数组扩容。
构造方法提供了多种初始化方式，包括创建一个具有默认初始容量的 PriorityBlockingQueue 实例、创建一个具有指定初始容量的 `
