jdk 常用的queue

queue队列，先进先出

1、优先级队列，元素有优先级

public class PriorityQueue<E> extends AbstractQueue<E> implements java.io.Serializable

队列使用堆排序，二叉树，使用数组保存数据，非线程安全

入队，新节点一直跟自己的父节点比较，不复合比较条件，交换位置，直到根节点

 public boolean offer(E e) {
        if (e == null)
            throw new NullPointerException();
        modCount++;
        int i = size;
        if (i >= queue.length)
            grow(i + 1);
        size = i + 1;
        if (i == 0)
            queue[0] = e;
        else
            siftUp(i, e);
        return true;
    }

 private void siftUp(int k, E x) {
        if (comparator != null)
            siftUpUsingComparator(k, x);
        else
            siftUpComparable(k, x);
    }

private void siftUpUsingComparator(int k, E x) {
        while (k > 0) {
            int parent = (k - 1) >>> 1;
            Object e = queue[parent];
            if (comparator.compare(x, (E) e) >= 0)
                break;
            queue[k] = e;
            k = parent;
        }
        queue[k] = x;
    }

出队，取出根节点值，把最后一个节点放到根节点，然后比较根节点和左右两个子节点，找到正确位置

 private void siftDownUsingComparator(int k, E x) {
        int half = size >>> 1;
        while (k < half) {
            int child = (k << 1) + 1;
            Object c = queue[child];
            int right = child + 1;
            if (right < size &&
                comparator.compare((E) c, (E) queue[right]) > 0)
                c = queue[child = right];
            if (comparator.compare(x, (E) c) <= 0)
                break;
            queue[k] = c;
            k = child;
        }
        queue[k] = x;
    }

对应线程安全的PriorityBlockingQueue，使用ReentrantLock，在入队出队总量等方法加锁，出队无值时候加入Condition队列

2、延时队列，元素有优先级和延时时间，出队时，时间未到，线程等待

public class DelayQueue<E extends Delayed> extends AbstractQueue<E> implements BlockingQueue<E> 

返回并移出队列头，如果元素没有到过期时间，则等待

 public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            for (;;) {
                E first = q.peek();
                if (first == null)
                    available.await();
                else {
                    long delay = first.getDelay(NANOSECONDS);
                    if (delay <= 0)
                        return q.poll();
                    first = null; // don't retain ref while waiting
                    if (leader != null)// 已经有一个线程先来取值了，则当前线程无期等待
                        available.await();
                    else {
                        Thread thisThread = Thread.currentThread();//设置当前线程为最先来取值的线程，
                        leader = thisThread;
                        try {
                            available.awaitNanos(delay);//等待指定时间，到时间自动唤醒
                        } finally {
                            if (leader == thisThread)
                                leader = null;
                        }
                    }
                }
            }
        } finally {
            if (leader == null && q.peek() != null)
                available.signal();//leader线程需要取完值后唤醒等待队列上的第一个线程，使它去尝试取新的队列头
            lock.unlock();
        }
    }

3、阻塞队列BlockingQueue，即入队时空间不足，线程等待有空间时继续入队，出队时队列为空，线程等待直到有元素

常用的有ArrayBlockingQueue，LinkedBlockingQueue，SynchronousQueue

ArrayBlockingQueue，初始化有界数组，数组存储

public ArrayBlockingQueue(int capacity, boolean fair) {
        if (capacity <= 0)
            throw new IllegalArgumentException();
        this.items = new Object[capacity];
        lock = new ReentrantLock(fair);
        notEmpty = lock.newCondition();
        notFull =  lock.newCondition();
    }

两个Condition，分别用来等待入队的线程，和出队的线程，入队后唤醒notEmpty，出队后唤醒notFull

LinkedBlockingQueue，有界，或者默认Integer.MAX_VALUE，使用链表存储节点，

 /** Lock held by take, poll, etc */
    private final ReentrantLock takeLock = new ReentrantLock();

    /** Wait queue for waiting takes */
    private final Condition notEmpty = takeLock.newCondition();

    /** Lock held by put, offer, etc */
    private final ReentrantLock putLock = new ReentrantLock();

    /** Wait queue for waiting puts */
    private final Condition notFull = putLock.newCondition();

使用了两个ReentrantLock分别控制入队出队，原理基本和ArrayBlockingQueue一致，Executors.newFixedThreadPool使用此队列

SynchronousQueue，没有容量或者"只有一个长度"，入队的线程直接阻塞，直到有出队的线程出现，双方交换数据，有点类似握手

有公平非公平两种模式，默认非公平，