PriorityBlockingQueue構造
PriorityB lockingQueueは、無制限のブロッキング優先度キューとチームが最優先かを返すたびにある
最低の要素を。その内部はそう直接秩序を確保されていないキュー要素を横断する、バランスの取れたバイナリヒープを使用して達成されます。Moは
、あなたがカスタマイズできるのルール比較カスタマイズする必要がある場合は、オブジェクトのcompareToメソッドは、比較ルールを提供用いて認識
コンパレータを。
PriorityBlockingQueue 内 部有一个数组 queue，用来存放队列元素，
size 用来存放队列元素个数 。 allocationspi nLock 是个自旋锁，其使用 CAS 操作来保证同
时只有一个线程可以扩容队列，状态为 0 或者 1 ，其中 0 表示当前没有进行扩容， l 表示
当前正在扩容。
由于这是一个优先级队列，所以有一个 比较器 comparator 用来比较元素大小 。 lock 独
占锁对象用来控制同时只能有一个线程可以进行入队、出队操作。 notEmpty 条件变量用
来实现 take 方法阻塞模式。这里没有 notFull 条件变量是因为这里的 put 操作是非阻塞的，
为啥要设计为非阻塞的，是因为这是无界队列。
在如下构造函数中，默认队列容量为 11 ，默认比较器为 null，也就是使用元素的
compareTo 方法进行 比较来确定元素的优先级 ， 这意味着队列元素必须实现了 Comparable
接口。
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 Comparator<? super E> comparator;
private final ReentrantLock lock;
private final Condition notEmpty;
private transient volatile int allocationSpinLock;
public PriorityBlockingQueue() {
this(DEFAULT_INITIAL_CAPACITY, null);
}
public PriorityBlockingQueue(int initialCapacity,
Comparator<? super E> comparator) {
if (initialCapacity < 1)
throw new IllegalArgumentException();
this.lock = new ReentrantLock();
this.notEmpty = lock.newCondition();
//比较器默认为null
this.comparator = comparator;
this.queue = new Object[initialCapacity];
}
offer操作
offer 操作的作用是在队列中插入一个元素，由于是无界队列 ， 所 以 一直返回 true
public boolean offer(E e) {
//检查是否为空
if (e == null)
throw new NullPointerException();
//获取锁
final ReentrantLock lock = this.lock;
lock.lock();
int n, cap;
Object[] array;
//1 如果当前元素个数〉＝队列容量，则扩容
while ((n = size) >= (cap = (array = queue).length))
tryGrow(array, cap);
try {
Comparator<? super E> cmp = comparator;
//2 默认比较器为 null
if (cmp == null)
siftUpComparable(n, e, array);
else
//3. 自定义比较器
siftUpUsingComparator(n, e, array, cmp);
//将队列元素数增加 1 ， 并且激活notEmpty的条件队列里面的 一个阻塞线程
size = n + 1;
//激活因调用 take （）方法被阻塞的线程
notEmpty.signal();
} finally {
//解锁
lock.unlock();
}
//返回
return true;
}
- 如何进行扩容和在内部建堆 tryGrow 方法
private void tryGrow(Object[] array, int oldCap) {
//释放获取的锁
lock.unlock(); // must release and then re-acquire main lock
Object[] newArray = null;
//CAS成功则扩容
if (allocationSpinLock == 0 &&
UNSAFE.compareAndSwapInt(this, allocationSpinLockOffset,
0, 1)) {
try {
//oldGap<64 则扩容 ， 执行oldcap+2 ，否则扩容 50 % ，并且最大为 MAX一皿RAY_SIZE
int newCap = oldCap + ((oldCap < 64) ?
(oldCap + 2) : // grow faster if small
(oldCap >> 1));
if (newCap - MAX_ARRAY_SIZE > 0) { // possible overflow
int minCap = oldCap + 1;
if (minCap < 0 || minCap > MAX_ARRAY_SIZE)
throw new OutOfMemoryError();
newCap = MAX_ARRAY_SIZE;
}
if (newCap > oldCap && queue == array)
newArray = new Object[newCap];
} finally {
allocationSpinLock = 0;
}
}
//第 一个线程CAS成功后，第二个线程会进入这段代码 ， 然后第二个线程让出 CPU ，尽量让第一个线程
//获取锁，但是这得不到保证
if (newArray == null) // back off if another thread is allocating
Thread.yield();
lock.lock();
if (newArray != null && queue == array) {
queue = newArray;
System.arraycopy(array, 0, newArray, 0, oldCap);
}
}
tryGrow 的作用 是扩容 。 这里为啥在扩容前要先释放锁，然后使用 CAS 控制只有一个
线程可以扩容成功？其实这里不先释放锁，也是可行的，也就是在整个扩容期间一直持有
锁，但是扩容是需要花时间的，如果扩容时还占用锁那么其他线程在这个时候是不能进行
出 队和入队操作的 ， 这大大降低 了并发性。 所以为了提高性能 ， 使用 CAS 控制只有 一个
线程可 以进行扩容，并且在扩容前释放锁，让其他线程可以进行入队和出队操作.
spinlock 锁使用 CAS 控制只有一 个 线程 可以 进行扩容， CAS 失败的线程会调用
Thread.yield（） 让出 CPU ， 目的是让扩容线程扩容后优先调用 lock.lock 重新获取锁，但是
这得不到保证。有可能 yield 的线程在扩容线程扩容完成前己经退 出， 并执行代码（ 6 ）获
取到了锁 ， 这时候获取到锁的线程发现 newArray 为 null 就会执行代码 Cl ）。如果当前数
组扩容还没完毕 ， 当前线程会再次调用 tryGrow 方法 ， 然后释放锁 ， 这又给扩容线程获取
锁提供了机会 ，如果这时候扩容线程还没扩容完毕 ，则 当 前线程释放锁后又调用 yield 方
法让出 CPU。所以当扩容线程进行扩容时， 其他线程原地自旋通过代码（ 1 ）检查当前扩
容是否完毕，扩容完毕后才退 出代码 Cl ） 的循环。
扩容线程扩容完毕后会重置自旋锁变量 allocationSpinLock 为 0，这里并没有使
用 UNSAFE 方法的 CAS 进行设置是因为 同时 只可 能 有一个线程获取到该锁 ， 并且
alloc ationSpinLock 被修饰为 了 volatile 的。当扩容线程扩容完毕后会执行代码 （ 6 ） 获取锁，
获取锁后复制当前 queue 里面的元素到新数组。
poll操作
poll 操作的作用是获取队列内部堆树的根节点元素，如果队列为空 ，则 返回 null 。
public E poll() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
//出队
return dequeue();
} finally {
lock.unlock();
}
}
dequeue
private E dequeue() {
//队列为空，返回 null
int n = size - 1;
if (n < 0)
return null;
else {
Object[] array = queue;
//获取队头元素
E result = (E) array[0];
E x = (E) array[n];
//获取队尾元素，并赋值为 null
array[n] = null;
Comparator<? super E> cmp = comparator;
//默认为空
if (cmp == null)
siftDownComparable(0, x, array, n);
else
siftDownUsingComparator(0, x, array, n, cmp);
size = n;
return result;
}
}
如果队列为空则 直接返回 null ，否则执行代码 Cl ）获取数组第一个
元素作为返回值存放到变量 Result 中，这里需要注意 ，数组里面的第一个元素是优先级最
小或者最大 的元素 ，出队操作就是返回这个元素。然后代码（ 2 ）获取队列尾部元素并存
放到变量 x 中 ，且置空尾部节点 ，然后执行代码。 ）将变量 x 插入到数组下标为 0 的位置 ，
之后重新调整堆为最大或者最小堆，然后返回 。 这里重要的是，去掉堆的根节点后，如何
使用剩下的节点重新调整一个最大或者最小堆 。 下面我们看下 siftDownComparable 的实现
代码
private static <T> void siftDownComparable(int k, T x, Object[] array,
int n) {
if (n > 0) {
Comparable<? super T> key = (Comparable<? super T>)x;
int half = n >>> 1; // loop while a non-leaf
while (k < half) {
int child = (k << 1) + 1; // assume left child is least
Object c = array[child];
int right = child + 1;
if (right < n &&
((Comparable<? super T>) c).compareTo((T) array[right]) > 0)
c = array[child = right];
if (key.compareTo((T) c) <= 0)
break;
array[k] = c;
k = child;
}
array[k] = key;
}
}
take操作-可中断
take 操作的作用是获取队列内部堆树的根节点元素 ， 如果队列为空则阻塞
public E take() throws InterruptedException {
//获取锁
final ReentrantLock lock = this.lock;
//可被中断
lock.lockInterruptibly();
E result;
try {
//如果队列为空，则！阻塞把当前线程放入notEmpty的条件队 71]
while ( (result = dequeue()) == null)
//阻塞当前队列
notEmpty.await();
} finally {
lock.unlock();
}
return result;
}
首先通过 lock. locklnterruptibly（） 获取独占锁，以这个方式获取的锁
会对中断进行响应 。然后调用 dequeue 方法返回堆树根节点元素，如果队列为空 ，则返回
fa l se 。然后当前线程调用 notEmpty.await（）阻塞挂起自己 ， 直到有线程调用了 offer（）方法（在
offer 方法内添加元素成功后会调用 notEmp ty.signa l 方法，这会激活一个阻塞在 notEmpty
的条件队列里面的一个线程）。另外，这里使用 while 循环而不是 if 语句是为了避免虚假
唤醒 。
size
public int size() {
//加锁
final ReentrantLock lock = this.lock;
lock.lock();
try {
//返回
return size;
} finally {
//释放锁
lock.unlock();
}
}
demo
package com.ghgcn.thread.lesson07.concurrentqueue;
import java.util.Random;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.ThreadLocalRandom;
/**
* @author 刘楠
* @since 2019/6/5
*/
public class TestPriorityBlockingQueue {
static class Task implements Comparable<Task> {
private Integer priority = 0;
private String taskName;
public int compareTo(Task o) {
if (this.priority >= o.getPriority()) {
return -1;
} else {
return 1;
}
}
public Integer getPriority() {
return priority;
}
public void setPriority(Integer priority) {
this.priority = priority;
}
public String getTaskName() {
return taskName;
}
public void setTaskName(String taskName) {
this.taskName = taskName;
}
public void doSomeThing() {
System.out.println(taskName + ":" + priority);
}
}
public static void main(String[] args) {
PriorityBlockingQueue<Task> queue = new PriorityBlockingQueue<Task>();
ThreadLocalRandom random = ThreadLocalRandom.current();
for (int i = 0; i < 10; ++i) {
Task task = new Task();
task.setPriority(random.nextInt(10));
task.setTaskName("taskName " + i);
queue.offer(task);
}
//取 出任务执行
while (!queue.isEmpty()){
Task task = queue.poll();
if(null!=task){
task.doSomeThing();
}
}
}
}
- 结果
タスク名8：9
TASKNAME 7：9
TASKNAME 0：8
TASKNAME 6：7
TASKNAME 9：6
TASKNAME 3：4
TASKNAME 4：4
TASKNAME 1：4
TASKNAME 5：3
TASKNAME 2：0
この結果から、タスクの実行順序と、彼らは問題ではないために、キューに入れられますが、それと
その優先順位があります。
バイナリヒープ優先メンテナンス要素を使用PriorityBlockingQueueキューは、使用してアレイ内の要素として
格納されたデータ構造を、アレイはスケーラブルです。要素の現在の数は> CASは、アルゴリズム=最大容量渡します
常にチームは、むしろメタ内部キューでの最長滞在よりも、木のヒープルートのチームの要素であることを確認するとき、拡張を
要素。要素を使用したcompareToメソッドは、比較ルールのデフォルトの優先順位の要素を提供し、ユーザーは優先順位をカスタマイズすることができます
比較ルールを