怎么说呢，

PriorityBlockingQueue 是一种基于数组实现的无界优先级阻塞队列。它默认使用长度为 11 的数组作为初始容量。实际使用时会根据需要自动扩容，直至程序资源耗尽为止。每次出队都会返回优先级最高的元素。

主要特性 & 常见痛点

1️⃣ 自动扩容却可能导致 OOM

虽然 PriorityBlockingQueue 声称是“无界”的。但在极端情况下内部数组会保持增长，最终可能触发 OutOfMemoryError。

2️⃣ 元素排序规则不明确

默认情况下队列按照元素的自然顺序进行升序排列。如果想要自定义排序，需要在构造函数中传入 Comparator。不过，痛点：很多新人误以为只要实现 Comparable 就能得到期望的顺序。同一优先级的元素在出队时并不保证 FIFO。

3️⃣ 线程安全细节难以把握

PriorityBlockingQueue 使用 ReentrantLock + Condition 实现阻塞和唤醒。痛点：如果不理解锁的粒度和条件变量的使用方式，容易出现假死或性能瓶颈。

构造方法概览

/** 创建一个使用自然顺序的优先级队列 */
public PriorityBlockingQueue {
this;}
/** 创建一个使用自定义 Comparator 的优先级队列 */
public PriorityBlockingQueue(int initialCapacity,Comparator comparator) {
if
throw new IllegalArgumentException;this.lock = new ReentrantLock;this.notEmpty = lock.newCondition;this.comparator = comparator;this.queue = new Object;其实，}
/** 默认初始容量 */
private static final int DEFAULT_INITIAL_CAPACITY = 11;

• 容量小于 1 会抛异常。
• If you pass a comparator it will be stored in comparator;orwise it stays null.
• The internal lock is a ReentrantLock,and blocking condition is a
• The underlying storage is an array;default capacity is 11 when using no‑arg constructor.

关键方法解析 & 常见误区

put

This method simply delegates to offer. Because queue is unbounded,it never blocks.

public void put {
offer;// never needs to block
}

offer

The real insertion logic lives here. It performs null‑check,acquires lock。grows array if needed,n sifts element up according to eir natural order or provided comparator.

public boolean offer {
if throw new NullPointerException;按理说，final ReentrantLock lock = this.lock;按理说，lock.lock;int n,cap，Object array;while >= .length))
tryGrow;try {
Comparator

Pain point: Developers often think that calling .offer` on a bounded queue may return false;here it always returns true because of unbounded nature.

.tryGrow

This method attempts to enlarge backing array without holding main lock all time. It releases lock briefly。uses a CAS spin‑lock to allocate a larger array,n re‑acquires main lock and swaps in new buffer.

private void tryGrow {
lock.unlock;// release main lock
Object newArray = null;if (allocationSpinLock == 0 &&
UNSAFE.compareAndSwapInt(this。allocationSpinLockOffset,0,1)) {
try {
int newCap = oldCap +?: )，if { // overflow guard
int minCap = oldCap + 1;if
throw new OutOfMemoryError;newCap = MAX_ARRAY_SIZE;}
if
newArray = new Object;} finally {
allocationSpinLock = 0;}
}
if
Thread.yield;// back off
lock.lock;// reacquire main lock
if {
queue = newArray;
System.arraycopy(array。0,newArray,0,oldCap);}
}

Pain point:

• If you inspect heap dumps you may see many temporary arrays during rapid growth – this can cause GC spikes.
• The CAS spin‑lock is low‑contention in practice but can become a bottleneck under extreme producer pressure.

Sift‑up 与 Sift‑down主要实现

.siftUpComparable

private static  void siftUpComparable(int k。T x,Object array) {
Comparable key = x;while {
int parent = >> 1;Object e = array;if e)>= 0)
break;array = e，k = parent;}
array = key;}

This builds a **min‑heap** by bubbling newly added element upward until its parent is smaller or equal.

.siftUpUsingComparator

private static  void siftUpUsingComparator(int k。T x,Object array,Comparator cmp) {
while {
int parent = >> 1;Object e = array;if e)>= 0)
break;array = e，k = parent;}
array = x，}

.siftDownComparable

private static  void siftDownComparable(int k。T x,Object array,int n) {
if {
Comparable key = x;其实，int half = n>> 1;// first leaf index
while { // while not leaf
int child = + 1;// left child
Object c = array;老实说，int right = child + 1;if (right  0)
c = array;if c) <= 0)
               break;
           array = c;
           k=child;
       }
       array=key;
   }
}

.siftDownUsingComparator

private static  void siftDownUsingComparator(int k。T x,Object array,int n,Comparator cmp){
if{
int half=n>>1;while{
int child=+1;Object c=array;int right=child+1;ifc,array)>0)
c=array;ifc)<=0)
            break;
         array=c;k=child;}
      array=x;}
}

The two pairs of methods are identical except for wher y use natural ordering or an external comparator.

.take 与 .dequeue 实现细节

.take

public E take throws InterruptedException{
final ReentrantLock lock=this.lock;lock.lockInterruptibly;E result=null;try{
while)==null){
notEmpty.await;// block until an element appears
}
}finally{
lock.unlock;}
return result;按理说，}

This method acquires lock interruptibly and waits on notEmpty。ensuring that consumers block efficiently when queue is empty.

.dequeue

private E dequeue{
int n=size-1;ifreturn null;Object a=queue;@SuppressWarnings
E result=a;// 最小元素
E x=a;// 最终一个元素准备下沉
a=null;Comparator

If re are multiple elements with identical priority,ir relative order after removal is

💡​ 实战建议与常用方法 💡

• Sizing wisely：If you know an approximate upper bound for pending tasks。pass it to constructor to avoid frequent resizing and GC churn.
• Avoid OOM：Add back‑pressure at producer side or use a bounded wrapper like
.
• Select proper comparator：If your business requires stable ordering among same priority items—use a secondary timestamp field inside your element and incorporate it into your comparator.
.
• Dive into heap layout when debugging：You can print `queue` 's internal `Object` via reflection to verify that heap invariants hold after each operation—helps catch accidental comparator bugs early.
.
• Avoid heavy contention on `lock` :.

---

如需更或实际案例，可访问语雀文档： 《Go.》 密码：xbkk 欢迎大家访问、提意见。

---