阻塞queue系列之PriorityBlockingQueue

和ArrayBlockingQueue一样内部使用数组实现，插入和获取数据使用同一把锁。不同的是，不管有无指定长度，都会实现可以实现自动扩容；在构造函数需传入comparator,用于插入元素时继续排序，若没有传入comparator，则插入的元素必须实现Comparatable接口。

构造函数

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

常用方法

和ArrayBlockingQueue常用方法基本相同，个别有点差异。

• offer 添加元素
  
  当容量满时，tryGrow(array, cap)方法实现自动扩容。
  当comparator不为null,根据comparator排序
  否则根据元素自己实现的Comparatable接口排序

---

• add 添加元素

 public boolean add(E e) {
        return offer(e);
    }

可见就是offer方法，因为不存在超容量情况，所以不会像ArrayBlockingQueue一样抛出异常。

---

• put 添加元素

public void put(E e) {
        offer(e); // never need to block
    }

可见就是offer方法，因为不存在超容量情况，所以不会像ArrayBlockingQueue会有阻塞情况。