【Java多线程】PriorityBlockingQueue源码分析 （二十五）

　　阅读本文前，请先了解AQS，阻塞队列，优先级队列，最小堆数据结构

　　参考：【Java多线程】队列同步器AQS（十一），【Java多线程】ArrayBlockingQueue阻塞队列原理分析（十六），【Java】PriorityQueue 的实现原理 

一、PriorityBlockingQueue介绍

　　一个无界的blocking queue使用与PriorityQueue类相同的排序规则，并提供阻塞检索操作。 虽然这个队列在逻辑上是无界的，但由于资源耗尽，尝试的添加可能会失败（导致OutOfMemoryError ）。 这个类不允许null元素。 根据natural ordering的优先级队列也不允许插入不可比较的对象（这样做在ClassCastException ）。

二、属性

// 默认队列容量
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;

// 自旋锁标识
private transient volatile int allocationSpinLock;

// 优先级队列
private PriorityQueue<E> q;

三、方法

1、构造方法

// 创建默认阻塞式优先级队列，已经初始化了数据数组
public PriorityBlockingQueue() {
    this(DEFAULT_INITIAL_CAPACITY, null);
}

// 根据初始值容量创建阻塞式优先级队列
public PriorityBlockingQueue(int initialCapacity) {
    this(initialCapacity, null);
}

// 根据创建比较器，默认容量为11，阻塞式优先级队列
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();
}

2、offer() 方法

// 放入元素到队列中 
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);

    // PriorityBlockingQueue 的数据结构是最小堆，与PriorityQueue结构相同
    // 最小堆：queue[0]，总是最小
    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;
}

3、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 {
            // 情况1、原容量小于 64，新容量为原容量的2倍+2
            // 情况2、原容量不小于 64，新容量为原容量的1.5倍
            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;
        }
    }

    // 扩容失败，返回，可能是其他线程在扩容
    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);
    }
}

4、take() 方法

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;
        // 最小堆，取出array[0]，最小值
        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;
    }
}

 四、示例

public class TestPriorityBlockingQueue {


    public static void main(String[] args) throws InterruptedException {

        PriorityBlockingQueue<Integer> queue = new PriorityBlockingQueue<>();

        for (int i = 0; i < 5; i++) {
            int finalI = i;
            new Thread(() -> {
                queue.offer(finalI);
                System.out.println("生产：" + finalI);
            }).start();
        }

        Thread.sleep(2000);

        for (int j = 0; j < 5; j++) {
            int finalI = j;
            new Thread(() -> {
                try {
                    System.out.println("消费：" + queue.take());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

五、总结

　　1、PriorityBlockingQueue 采用数组来存储数据的，数据结构是最小堆

　　2、PriorityBlockingQueue 扩容时

　　　　- 原容量小于 64，新容量为原容量的2倍+2

　　　　- 原容量不小于 64，新容量为原容量的1.5倍

　　3、由于是最小堆的数据结构，queue[0]最小，每次放入数据 和 取出数据，要进行数据调整（上浮，下浮）；

　　4、PriorityBlockingQueue 是线程安全的