PriorityBlockingQueue 底层原理和应用详解

优先级队列，线程安全（添加、读取都进行了加锁）、无界、读阻塞的队列，底层采用的堆结构实现（二叉树），默认是小根堆，最小的或者最大的元素会一直置顶，每次获取都取最顶端的数据

（源码）无界,offer或者put 添加元素时，如果容器满了会尝试tryGrow扩容

	public void put(E e) {
        offer(e); // never need to block
    }	
	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;
    }
    private void tryGrow(Object[] array, int oldCap) {
        lock.unlock(); // must release and then re-acquire main lock
        Object[] newArray = null;
        if (allocationSpinLock == 0 &&
            UNSAFE.compareAndSwapInt(this, allocationSpinLockOffset,
                                     0, 1)) {
            try {
                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);
        }
    }

（源码）获取元素会进行阻塞

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;
    }

示例

public class T04_PriorityBlockingQueue {
	public static void main(String[] args) throws InterruptedException {
		BlockingQueue q = new PriorityBlockingQueue<>();
		new Thread(()-> {
			for (int i = 0; i < 10; i++)
				try {
					// 添加10个元素
					q.put(i);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
		}).start(); 
		new Thread(()-> {
			for (int i = 0; i < 11; i++)
				try {
					// 取加11个元素
					int res = (int) q.take();
					System.out.println(res);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
		}).start(); 	
	}
}

应用场景

1，在大量数据中，找最大值或者最小值的情况下。