并发队列之PriorityBlockingQueue
这一篇说一下PriorityBlockingQueue，引用书中的一句话：这就是带优先级的无界阻塞队列，每次出队都返回优先级最高或者最低的元素(这里规则可以自己制定)，内部是使用平衡二叉树实现的，遍历不保证有序；
其实也比较容易，就是基于数组实现的一个平衡二叉树，不了解平衡二叉树的可以先了解一下，别想的太难，原理跟链表差不多，只不过链表中指向下一个节点的只有一个，而平衡二叉树中有两个，一个左，一个右，还有左边的节点的值小于当前节点的值，右边节点的值大于当前节点的值；看看平衡二叉树的增删改查即可；
一.认识PriorityBlockingQueue
底层是以数组实现的，我们看看几个重要的属性：
//队列默认初始化容量 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; //如果队列是空的，还有线程来队列取数据，就阻塞 //这里只有一个条件变量，因为这个队列是无界的，向队列中插入数据的话就用CAS操作就行了 private final Condition notEmpty; //一个自旋锁，CAS使得同时只有一个线程可以进行扩容，0表示没有进行扩容，1表示正在进行扩容 private transient volatile int allocationSpinLock;
简单看看构造器：
//默认数组大小是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]; } //这个构造器也可以传入一个集合 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<? extends E> ss = (SortedSet<? extends E>) c; this.comparator = (Comparator<? super E>) ss.comparator(); heapify = false; } else if (c instanceof 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; // If c.toArray incorrectly doesn't return Object[], copy it. if (a.getClass() != Object[].class) a = Arrays.copyOf(a, n, Object[].class); if (screen && (n == 1 || this.comparator != null)) { for (int i = 0; i < n; ++i) if (a[i] == null) throw new NullPointerException(); } this.queue = a; this.size = n; if (heapify) heapify(); }
有兴趣的可以看看下面这个图，说的更详细，个人觉得看重要的地方就行了；
二.offer方法
在队列中插入一个元素，由于是无界队列，所以一直返回true；
public boolean offer(E e) { //如果传入的是null，就抛异常 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]默认比较器为空时 if (cmp == null) siftUpComparable(n, e, array); else //[3]默认比较器不为空就用我们传进去的默认比较器 siftUpUsingComparator(n, e, array, cmp); //数组实际数量加一 size = n + 1; //唤醒notEmpty条件队列中的线程 notEmpty.signal(); } finally { //释放锁 lock.unlock(); } return true; }
上面的代码中，我们就关注那三个地方就行了，首先是[1]中扩容：
private void tryGrow(Object[] array, int oldCap) { //首先释放获取的锁，这里不释放也行，只是扩容有的时候很慢，需要花时间，此时入队和出队操作就不能进行了，极大地降低了并发性 lock.unlock(); // must release and then re-acquire main lock Object[] newArray = null; //自旋锁为0表示队列此时没有进行扩容，然后用CAS将自旋锁从0该为1 if (allocationSpinLock == 0 && UNSAFE.compareAndSwapInt(this, allocationSpinLockOffset, 0, 1)) { try { //用这个算法确定扩容后的数组容量，可以看到如果当前数组容量小于64，新数组容量就是2n+2，大于64，新的容量就是3n/2 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 { //扩容完毕就将自旋锁变为0 allocationSpinLock = 0; } } //第一个线程在上面的if中执行CAS成功之后，第二个线程就会到这里，然后执行yield方法让出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); } }
再看[2]中的默认的比较器：
//这里k表示数组中实际数量，x表示要插入到数组中的数据，array表示存放数据的数组 private static <T> void siftUpComparable(int k, T x, Object[] array) { //由此可知，我们要放进数组中的数据类型，必须要是实现了Comparable接口的 Comparable<? super T> key = (Comparable<? super T>) x; //这里判断数组中有没有数据，第一次插入数据的时候，k=0，不满足这个循环条件，那就直接走最下面设置array[0] = key //满足这个条件的话，首先获取父节点的索引，然后取出值，再比较该值和需要插入值的大小，决定是跳出循环还是继续循环 //这里比较重要，这个循环就是不断的调整二叉树平衡的，下面我们画图看看 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; }
随便举个例子看看怎么把平衡二叉树中的元素放到数组中，节点中的数据类型就以Integer了，其实就是将每一层从做到右一次放到数组中存起来，很明显，在数组中不是从小到大的顺序的；
这里注意一点，平衡二叉树的存放顺序不是唯一的，有很多种情况，跟你的存放顺序有关!
所以我们看看siftUpComparable方法中的while循环是怎么进行的？假设第一次调用offer(3),也就是调用siftUpComparable(0,3,array)，这里假设array有足够的大小，不考虑扩容，那么第一次会走到while循环后面执行array[0]=3，下图所示：
第二次调用offer(1),也就是调用siftUpComparable(1,1,array)，k=1，parent=0,所以父节点此时应该是3，然后1<3，不满足if语句，设置array[1]=3，k=0，然后继续循环不满足条件，执行array[0]=1，下图所示：
第三次调用offer(7)，也就是调用siftUpComparable(2,7,array)，k=2，parent=0，父节点为索引0的位置也就是1，因为7>1满足if语句，所以break跳出循环，执行array[2]=7,下图所示：
第四次调用offer(2),也就是调用siftUpComparable(3,2,array)，k=3，parent=（k-1）>>>1=1,所以父节点表示索引为1的位置，也就是3，因为2<3,不满足if语句，所以设置array[3]=3,k=1,再进行一次循环，parent=0，此时父节点的值是1，2<3,不满足if，设置array[1]=1,k=0;再继续循环不满足循环条件，跳出循环，设置array[0] = 2
还是很容易的，有兴趣的话再多试试添加几个节点啊！其实还有[3]中使用我们自定义的比较器进行比较，其实i和上面代码一样的，另外put方法就是调用的offer方法，这里就不多说了
三.poll方法
poll方法的作用是获取并删除队列内部二叉树的根节点，如果队列为空，就返回nul；
public E poll() { final ReentrantLock lock = this.lock; //获取独占锁，说明此时不能有其他线程进行入队和出队操作，但是可以进行扩容 lock.lock(); try { //获取并删除根节点，方法如下 return dequeue(); } finally { //释放独占锁 lock.unlock(); } } //这个方法可以好好看看，很有意思 private E dequeue() { int n = size - 1; //如果队列为空，就返回null if (n < 0) return null; else { //否则就先取到数组 Object[] array = queue; //取到第0个元素，这个也就是要返回的根节点 E result = (E) array[0]; //获取队列实际数量的最后一个元素，并把该位置赋值为null 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; } } private static <T> void siftDownComparable(int k, T x, Object[] array, int n) { if (n > 0) { Comparable<? super T> key = (Comparable<? super T>)x; //[1] int half = n >>> 1; // loop while a non-leaf //[2] while (k < half) { int child = (k << 1) + 1; // assume left child is least Object c = array[child]; int right = child + 1; //[3] if (right < n &&((Comparable<? super T>) c).compareTo((T) array[right]) > 0) c = array[child = right]; //[4] if (key.compareTo((T) c) <= 0) break; array[k] = c; k = child; } array[k] = key; } }
所以我们主要的是看看siftDownComparable方法中是怎么将一个去掉了根节点的平衡二叉树调整平衡的；比如现在有如下所示的平衡二叉树：
调用poll方法，先是把最后一个元素保存起来x=3，然后将最后一个位置设置为null，此时实际调用的是siftDownComparable(0,3,array,3)，key=3，half=1，k=0，n=3，满足[2],于是child=1，c=1，right=2，不满足[3]，不满足[4]，设置array[0]=1，k=1；继续循环，不满足循环条件，跳出循环，直接设置array[1]=3，最后poll方法返回的时2，下图所示：
其实可以简单的说说，最开始将数组中最后一个值X保存起来在适当时机插入到二叉树中，什么时候是适当时机呢？首先去掉根节点之后，得到根节点左子节点和右子节点的值leftVal和rightVal，如果X比leftVal小，那就直接把X放入到根节点的位置，整个平衡二叉树就平衡了！如果X比leftVal大，那就将leftVal的值设置到根节点中，再以左子节点做递归，继续比较X和左子节点的左节点的大小!仔细看看也没啥。
四.take方法
这个方法作用是获取二叉树中的根节点，也就是数组的第一个节点，队列为空，就阻塞；
public E take() throws InterruptedException { //获取锁，可中断 final ReentrantLock lock = this.lock; lock.lockInterruptibly(); E result; try { //如果二叉树为空了，那么dequeue方法就会返回null，然后这里就会阻塞 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; } }
五.一个简单的例子
前面看了这个多方法，那就说说怎么使用吧，看看PriorityBlockingQueue这个阻塞队列怎么使用；
package com.example.demo.study; import java.util.Random; import java.util.concurrent.PriorityBlockingQueue; import lombok.Data; public class Study0208 { @Data static class MyTask implements Comparable<MyTask>{ private int priority=0; private String taskName; @Override public int compareTo(MyTask o) { if (this.priority>o.getPriority()) { return 1; } return -1; } } public static void main(String[] args) { PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<MyTask>(); Random random = new Random(); //往队列中放是个任务，从TaskName是按照顺序放进去的，优先级是随机的 for (int i = 1; i < 11; i++) { MyTask task = new MyTask(); task.setPriority(random.nextInt(10)); task.setTaskName("taskName"+i); queue.offer(task); } //从队列中取出任务，这里是按照优先级去拿出来的,相当于是根据优先级做了一个排序 while(!queue.isEmpty()) { MyTask pollTask = queue.poll(); System.out.println(pollTask.toString()); } } }
