简介
PriorityBlockingQueue是一个支持优先级的无界阻塞队列,直到系统资源耗尽。默认情况下元素采用自然顺序升序排列。也可以自定义类实现compareTo()方法来指定元素排序规则,或者初始化PriorityBlockingQueue时,指定构造参数Comparator来对元素进行排序。但需要注意的是不能保证同优先级元素的顺序。PriorityBlockingQueue是基于最小二叉堆实现,使用基于CAS实现的自旋锁来控制队列的动态扩容,保证了扩容操作不会阻塞take操作的执行。
主要属性
// 数组的默认大小
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;
// 扩容时需要用到这个变量,CAS更新这个值,只有更新成功了才能进行扩容
private transient volatile int allocationSpinLock;
//
private PriorityQueue<E> q;
// 构造函数
public PriorityBlockingQueue() {
this(DEFAULT_INITIAL_CAPACITY, null);
}
public PriorityBlockingQueue(int initialCapacity) {
this(initialCapacity, null);
}
public PriorityBlockingQueue(int initialCapacity,
Comparator<? super E> comparator) {
if (initialCapacity < 1)
throw new IllegalArgumentException();
this.lock = new ReentrantLock();
this.notEmpty = lock.newCondition();
this.comparator = comparator;
this.queue = new Object[initialCapacity];
}
入队
// 入队
public void put(E e) {
offer(e); // 入队不需要阻塞,因为当队列满了就会进行扩容
}
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;
// 根据不同的选择器选择不同方法
if (cmp == null)
siftUpComparable(n, e, array);
else
siftUpUsingComparator(n, e, array, cmp);
// 元素个数加1
size = n + 1;
// 唤醒因为出队元素而被阻塞的线程
notEmpty.signal();
} finally {
// 释放锁
lock.unlock();
}
return true;
}
// 自下而上进行堆化
private static <T> void siftUpComparable(int k, T x, Object[] array) {
Comparable<? super T> key = (Comparable<? super T>) x;
while (k > 0) {
int parent = (k - 1) >>> 1; // 找到父元素,这里相当于(k-1)/2
// 获取父元素的值
Object e = array[parent];
// 插入的元素大于等于父元素,则直接跳出循环。因为这里构建的是小根堆。
if (key.compareTo((T) e) >= 0)
break;
// 如果插入的元素小于父元素,则需要与父节点交换位置,将位置k设置为父元素的值
array[k] = e;
// 因为此时已经跟父元素交换了位置,所以需要将k设置为父元素的位置,然后继续与父元素比较
k = parent;
}
// 最后找到应该插入的位置
array[k] = key;
}
// 扩容
private void tryGrow(Object[] array, int oldCap) {
lock.unlock(); // 先释放锁
Object[] newArray = null;
// 使用CAS更新allocationSpinLock
if (allocationSpinLock == 0 &&
UNSAFE.compareAndSwapInt(this, allocationSpinLockOffset,
0, 1)) {
// 如果更新成功,说明当前线程获取扩容资格
try {
// 旧容量小于64,新容量则是旧容量的两倍+2
// 旧容量大于64,新容量则增加旧容量的一半
int newCap = oldCap + ((oldCap < 64) ?
(oldCap + 2) : // grow faster if small
(oldCap >> 1));
if (newCap - MAX_ARRAY_SIZE > 0) { // 判断是否溢出
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;
}
}
// 如果 newArray 为空,说明当前线程没有获取到扩容的锁,则让出CPU
if (newArray == null)
Thread.yield();
// 再次加锁
lock.lock();
if (newArray != null && queue == array) {
// 新数组创建成功并且队列没有被替换
// 将队列数组指向新创建的数组
queue = newArray;
// 将旧数组元素复制到新数组中
System.arraycopy(array, 0, newArray, 0, oldCap);
}
}
tryGrow 目的是扩容,其实这里不先释放锁也是可以的,也就是在整个扩容期间一直持有锁,但是扩容是需要花时间的,如果扩容的时候还占用锁,那么其他线程在这个时候是不能进行出队和入队操作的,这大大降低了并发性。所以为了提高性能,使用CAS控制只有一个线程可以进行扩容,并且在扩容前释放了锁,让其他线程可以进行入队和出队操作。
使用CAS控制只有一个线程可以进行扩容,CAS失败的线程会调用Thread.yield() 让出 cpu,目的是为了让扩容线程扩容后优先调用 lock.lock 重新获取锁,但是这得不到一定的保证。
有可能yield的线程在扩容线程扩容完成前已经退出,并执行了代码lock.lock();获取到了锁。如果当前数组扩容还没完毕,当前线程会再次调用tryGrow方法,然后释放锁,这又给扩容线程获取锁提供了机会,如果这时候扩容线程还没扩容完毕,则当前线程释放锁后又调用yield方法让出CPU。扩容线程进行扩容期间,其他线程是原地自旋通过代码(1)检查当前扩容是否完毕,等扩容完毕后才退出代码(1)的循环。
出队
// 出队,若队列为空,将会阻塞
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
// 获取锁
lock.lockInterruptibly();
E result;
try {
// 如果队列为空,就阻塞当前线程,直到被唤醒
while ( (result = dequeue()) == null)
notEmpty.await();
} finally {
// 释放锁
lock.unlock();
}
return result;
}
// 出队
private E dequeue() {
int n = size - 1; // n 代表数组末尾元素的下标,也代表出队之后队列中的元素个数
// 如果n < 0,说明队列为空,返回null
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;
}
}
// 这里相当于把末尾元素与首元素调换,然后重新调整堆,使得首元素为最小
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) {
// 获取左子树位置,child = 2*k+1
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;
}
}