PriorityBlockingQueue详解
PriorityBlockingQueue介绍
【1】PriorityBlockingQueue是一个无界的基于数组的优先级阻塞队列，数组的默认长度是11，也可以指定数组的长度，且可以无限的扩充，直到资源消耗尽为止，每次出队都返回优先级别最高的或者最低的元素。默认情况下元素采用自然顺序升序排序，当然我们也可以通过构造函数来指定Comparator来对元素进行排序。需要注意的是PriorityBlockingQueue不能保证同优先级元素的顺序。
【2】优先级队列PriorityQueue： 队列中每个元素都有一个优先级，出队的时候，优先级最高的先出。
PriorityBlockingQueue的源码分析
【1】属性值
//默认容量 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;
【2】构造函数
//没有指定容量，则容量默认11 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]; }
【3】核心方法分析
1）核心扩容函数
//扩容函数 private void tryGrow(Object[] array, int oldCap) { lock.unlock(); //必须释放然后重新获得主锁，这一步的意义在于所有操作共享一把锁，在进行扩容时（因为写已满），释放锁（不能写，要等待扩容完才能写），提供给读操作 Object[] newArray = null; // CAS 轻量级锁加锁，避免并发扩容 if (allocationSpinLock == 0 && UNSAFE.compareAndSwapInt(this, allocationSpinLockOffset, 0, 1)) { try { // 扩容步长，旧值小于64时，变为两倍+2。大于64时，变为1.5倍。 int newCap = oldCap + ((oldCap < 64) ? (oldCap + 2) : (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; } } // 并发扩容时，线程让出 cpu 执行时间，给其他线程执行，自己稍后执行，原因：加锁不成功必然有其他线程也在扩容，在等待过程中让出资源给其他线程利用 if (newArray == null) Thread.yield(); //重新加锁 lock.lock(); //变更内存指向，利用内存拷贝复制旧数据 if (newArray != null && queue == array) { queue = newArray; System.arraycopy(array, 0, newArray, 0, oldCap); } }
2）入队方法
public void put(E e) { offer(e); // never need to block } public boolean add(E e) { return 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; 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); size = n + 1; notEmpty.signal(); } finally { lock.unlock(); } return true; }
4）队列填入方式
代码展示
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; Object e = array[parent]; if (key.compareTo((T) e) >= 0) break; array[k] = e; k = parent; } array[k] = key; } //雷同上面的不过比较器采用传入的 private static <T> void siftUpUsingComparator(int k, T x, Object[] array, Comparator<? super T> cmp) { while (k > 0) { int parent = (k - 1) >>> 1; Object e = array[parent]; if (cmp.compare(x, (T) e) >= 0) break; array[k] = e; k = parent; } array[k] = x; }
图解说明
1.利用了满二叉树的理念，(k - 1) >>> 1可以获得存入节点的父节点下标，然后进行比较。若判断应该上升，则将父节点置于k存储的地方。
2.重复循环，知道二叉树root节点，或者已经找到了合适的位置
4）出队方法
public E poll() { final ReentrantLock lock = this.lock; lock.lock(); try { return dequeue(); } finally { lock.unlock(); } } 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; if (n < 0) return null; else { Object[] array = queue; //将头节点取出返回 E result = (E) array[0]; //将末尾节点当做向头节点位置存入的节点 E x = (E) array[n]; 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; } }
5）队列修正方式
代码展示
private static <T> void siftDownComparable(int k, T x, Object[] array, int n) { if (n > 0) { Comparable<? super T> key = (Comparable<? super T>)x; //过滤掉最后一层的元素（以为满二叉树中，最后一层占据的元素就是n/2） 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; } } private static <T> void siftDownUsingComparator(int k, T x, Object[] array, int n,Comparator<? super T> cmp) { if (n > 0) { int half = n >>> 1; while (k < half) { int child = (k << 1) + 1; Object c = array[child]; int right = child + 1; if (right < n && cmp.compare((T) c, (T) array[right]) > 0) c = array[child = right]; if (cmp.compare(x, (T) c) <= 0) break; array[k] = c; k = child; } array[k] = x; } }
图解说明
1.采用尾结点代替头节点，然后利用下沉的方式来修正优先队列里面的数据。
2.下沉限制在倒数第二层，以为倒数第二层就会与倒数第一层进行比较了，所以应该进行限制（下标位置超出倒数第二层的最大下标就应该停止了）
3.其次看的时候，可以把左右子树都当做一个小的满二叉树，不断逐层划分，这样条理更清晰。
PriorityBlockingQueue总结
【1】一个支持优先级排序的无界阻塞队列，优先级高的先出队，优先级低的后出队
【2】数据结构：数组+二叉堆（默认容量11，可指定初始容量，会自动扩容，最大容量是(Integer.MAX_VALUE - 8)）
【3】锁：ReentrantLock，存取是同一把锁
【4】阻塞对象：NotEmpty，出队，队列为空时阻塞
【5】入队，不阻塞，永远返回成功，无界；根据比较器进行堆化（排序）自下而上，如果比较器为 null，则按照自然顺序排序，传入比较器对象就按照比较器的顺序排序。
【6】出队，优先级最高的元素在堆顶（弹出堆顶元素），弹出前比较两个子节点再进行堆化（自上而下）。
【7】应用场景：1.业务办理排队叫号，VIP客户插队；2.电商抢购活动，会员级别高的用户优先抢购到商品；
