PriorityBlockingQueue

       优先级阻塞队列PriorityBlockingQueue，不是FIFO队列，他要求使用者提供一个Comparetor比较器，或者队列内部元素实现Comparable接口，队头元素会是整个队列里的最小元素。

       PriorityBlockingQueue的优先级特性的实现方式和PriorityQueue的实现一致。

       PriorityBlockingQueue使用数组实现的最小堆结构，利用的原理是：在数组实现的完全二叉树中，父节点的下标为子节点下标除以2。

       PriorityBlockingQueue是不定长的，会随着数据的增长会逐步扩容，其最大容量为Integer.MAX_VALUE-8，如果容量超出这个值，那么会产生OutOfMemoryError。

1， 成员变量

//数据容器
private transient Object[] queue;
//队列里的元素数量(因为队列尾端还有空节点，所以queue数组长度不代表数量)
private transient int size;
//比较器，如果没有才会使用元素的作为Cpomarable，那么在构造函数里初始化
private transient Comparator<? super E> comparator;
//所有公开操作的重入锁
private final ReentrantLock lock;
//非空条件监视器，在队列为空时，阻塞当前队列（队列具备孔融功能，所以没有notFull锁）
private final Condition notEmpty;
//用于重新分配queue大小的自旋锁
private transient volatile int allocationSpinLock;
//一个辅助队列，仅用于序列化
private PriorityQueue<E> q;

2， add/put/offer方法 

　　add和put的实现最终都委托给了offer，所以这里会终点讲解offer方法的实现：

public boolean add(E e) {return offer(e);}
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;
    //队列元素超长时，增加容量，该循环和tryGrow方法共同构成一个自旋锁
    while((n = size) >= (cap = (array = queue).length)) {
        tryGrow(array, cap);
    }
    try {
        //根据是否设置了comparator来确定比较方式
        Comparator<? super E> cmp = comparator;
        //siftUp是最小堆的上浮方法，对于插入队尾n的元素e，确定它在最小堆的位置
        if(cmp == null) {
            siftUpComparable(n, e, array, cmp);
        } else {
            siftUpUsingComparator(n, e, array, cmp);
        }
        size = n + 1;
        //在插入成功后，唤醒非空对象监视器阻塞线程，以执行出队方法
        notEmpty.signal();
    } finally {
        lock.unlock;
    }
    return true;
}

       通过offer的源码可以看出，它是线程安全的，在多线程环境中，lock的使用可以保证重新分配容量的操作和入队上浮操作在同一个时间点，只有一个线程在执行。 

       siftUpComparable/shiftUpUsingComparator这两个方法用于实现最小堆增加元素后的上浮操作，他们的实现和PriorityQueue完全一致。

3， tryGrow方法

　　tryGrow方法用于在size超出queue的长度时，尝试对数组进行扩容。

private void tryGrow(Object[] array, int oldCap) {
    //释放锁，以便更多线程进入
    lock.unlock();
    Object[] newArray = null;
    //allocationSpinLock为1时，会跳过该步骤，UNSAFE的CAS操作保证了这个变更的原子性
    if(allocationSpinLock == 0 && UNSAFE.compareAndSwapInt(this, allocationSpinLockOffset, 0, 1)) {
        try {
            //体积增长策略，如果旧容量小于64，则容量翻倍再+2，反之扩容1/2
            int newCap = oldCap + ((oldCap < 64) ? (oldCap + 2) : (oldCap >> 1));
            //如果新容量超出最大容量，那么设置新容量为最大容量
            if(newCap - MAX_ARRAY_SIZE > 0) {
                //旧容量已经达到极限时，无法增长，则抛出OOM错误
                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;
        }
        //new Array == null基本是因为allocationSpinLock为1，说明其他线程正在扩容，让出时间片
        if(newArray == null) {
            Thread.yield();
            //重新上锁，保证queue的真正扩容阶段的线程安全
            lock.lock();
            if(newArray != null && queue == array) {
                queue = newArray;
                System.arraycopy(array, 0, new Array. 0, oldCap);
            }
        }
    }
}

       tryGrow方法的实现较为复杂，为什么要使用如此复杂的方式呢？原因是为了同时兼顾效率和安全性，在理解的时候需要注意： 

1)       最耗时的操作是System.arraycopy操作，而计算出新容量和分配一个新的空数组，耗时不多，所以扩容操作只应该在必要的时候进行，在扩容的时候，需要释放锁从而使poll之类的出队操作可继续执行，假设有出队操作执行了，而导致newCap <= oldCap,则newArray会始终为null，不会扩容。

2)       由于PriorityBlockingQueue的出队与入队方法共用一把锁，unlock也可能会导致其他入队线程继续执行，为了保证扩容操作的线程安全，所以CAS+自旋锁来保证扩容计算只有单个线程执行。

3)       Trhead.yield()方法，只会在自旋检测失败或者扩容失败的情况下调用，既然扩容失败，如果不让出时间片，那么该线程会继续执行tryGrow外部的while循环，在进行一次检测，这明显失效率的损失，所以调用yield，尽量让检测成功的线程去持有锁，当然，它不能保证百分之百让出成功。

4)       queue != array是个特殊情况，发生System.arraycopy之前，是为了保证在扩容过程中，其他线程持有的旧queue不会造成线程不安全。

4， poll、take、peek方法

　　这三个方法用于出队，也都是使用重入锁来保证线程安全的。

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    E reault;
    try {
        //多次请求出队，请求失败则说明队列我empty，notEmpty阻塞当前线程
        while((result = dequeue()) == null) {
            notEmpty.await();
        }
    } finally {
        lock.unlock();
    }
    return result;
}
public E poll() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        //执行一次出队，并返回出队结果
        return dequeue();
    } finally {
        lock.unlock();
    }
}
public E poll(long timeout, TimeUnit unit) throws InterruptedException {
    long nanos = unit.toNanos(timeout);
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    E result;
    try {
        //多次请求出队，timeout和timeUnit参数决定了出队失败后重试时长
        while((result = dequeue()) == null && nanos > 0) {
            nanos = notEmpty.awaitNanos(nanos);
        }
    } finally {
        lock.unlock();
    }
    return result;
}
public E peek() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        //查看队头，最小堆构成队列，队头始终未0
        return (size == 0) ? null : (E)queue[0];
    } finally {
        lock.unlock();
    }
}

5， dequeue方法 

　　通过对出队的多个方法的解析，可以注意到，真正执行出队的方法是dequeue。dequeue在移除队头元素的同时，还需要维护最小堆的特性。

private E dequeue() {
    int n = size - 1;
    if(n < 0) {
        return null;
    } else {
        Object[] array = queue;
        //获取队头元素result
        E result = (E)array[0];
        //获取队尾元素
        array[n] = null;
        Comparator<? super E> cmp = comparator;
        //siftDown操作会把队尾元素默认为队头位置，并且使用沉降操作来维护最小堆
        if(cmp == null) {
            siftDownComparable(0, x, array, n);
        } else {
            siftDownUsingComparator(0, x, array, n, cmp);
        }
        size = n;
        return result;
    }
}

       siftDownComparable/siftDownUsingComparator这两个方法用于实现最小堆移除元素后的沉降操作，他们的实现和PriorityQueue完全一致。