并发包中的并发队列

一、ConcurrentLinkedQueue——无界非阻塞队列（链式存储）

  

 ConcurrentLinkedQueue内部的队列是单链表实现的，

1.链表节点：静态内部类Node，没有其他设计，仅unsafe保证原子性

    private static class Node<E> {
        volatile E item;
        volatile Node<E> next;

        Node(E item) {
            UNSAFE.putObject(this, itemOffset, item);
        }

        boolean casItem(E cmp, E val) {
            return UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);
        }

        void lazySetNext(Node<E> val) {
            UNSAFE.putOrderedObject(this, nextOffset, val);
        }

        boolean casNext(Node<E> cmp, Node<E> val) {
            return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
        }

        private static final sun.misc.Unsafe UNSAFE;
        private static final long itemOffset;
        private static final long nextOffset;

        static {
            try {
                UNSAFE = sun.misc.Unsafe.getUnsafe();
                Class<?> k = Node.class;
                itemOffset = UNSAFE.objectFieldOffset
                    (k.getDeclaredField("item"));
                nextOffset = UNSAFE.objectFieldOffset
                    (k.getDeclaredField("next"));
            } catch (Exception e) {
                throw new Error(e);
            }
        }
    }

2.变量与构造方法

    private transient volatile Node<E> head;//单链表头节点
    private transient volatile Node<E> tail;//单链表尾节点

    public ConcurrentLinkedQueue() {
        head = tail = new Node<E>(null);
    }

    public ConcurrentLinkedQueue(Collection<? extends E> c) {
        Node<E> h = null, t = null;
        for (E e : c) {
            checkNotNull(e);
            Node<E> newNode = new Node<E>(e);
            if (h == null)
                h = t = newNode;
            else {
                t.lazySetNext(newNode);
                t = newNode;
            }
        }
        if (h == null)
            h = t = new Node<E>(null);
        head = h;
        tail = t;
    }

3.方法

bealoon offer(E e):入队

    public boolean offer(E e) {
        //非空检查
        checkNotNull(e);
        //创建节点Node对象，构造方法中unsafe保证原子性
        final Node<E> newNode = new Node<E>(e);
        //从尾节点入队
        for (Node<E> t = tail, p = t;;) {
            Node<E> q = p.next;
            if (q == null) {
                // q == null 说明p是尾节点 CAS入队
                if (p.casNext(null, newNode)) {
                    //与下面else，两次offer后tail指向尾节点
                    if (p != t) // hop two nodes at a time
                        casTail(t, newNode);  // Failure is OK.
                    return true;
                }
                // Lost CAS race to another thread; re-read next
            }
            else if (p == q)
                //poll引起的
                p = (t != (t = tail)) ? t : head;
            else
                // Check for tail upda tes after two hops.
                p = (p != t && t != (t = tail)) ? t : q;
        }
    }

 入队过程：offer两次后，tail才会指向尾节点

E poll():出队

    public E poll() {
        restartFromHead:
        for (;;) {
            for (Node<E> h = head, p = h, q;;) {
                E item = p.item;

                if (item != null && p.casItem(item, null)) {
                    // Successful CAS is the linearization point
                    // for item to be removed from this queue.
                    if (p != h) // hop two nodes at a time
                        updateHead(h, ((q = p.next) != null) ? q : p);
                    return item;
                }
                else if ((q = p.next) == null) {
                    updateHead(h, p);
                    return null;
                }
                else if (p == q)
                    continue restartFromHead;
                else
                    p = q;
            }
        }
    }

出队，三种情景

1）空节点时，不变

2）一个节点时，头节点自循环，也就对应offer中p == q的情景

3）多个节点时，头节点自循环，head指针会一次跳过两个节点。

 E peek():获取队首节点，不删除，但是第一次调用时会删除哨兵节点（初始化head、tail指向的空节点）

    public E peek() {
        restartFromHead:
        for (;;) {
            for (Node<E> h = head, p = h, q;;) {
                E item = p.item;
                if (item != null || (q = p.next) == null) {
                    updateHead(h, p);
                    return item;
                }
                else if (p == q)
                    continue restartFromHead;
                else
                    p = q;
            }
        }
    }

remove存在元素就删除第一个该元素

size和contains方法在并发环境下不常用，因为CAS未加锁，会导致结果不精确（保证最终一致性，不保证实时一致性）

二、LinkedBlockingQueue——有界阻塞队列（链式存储）

 

    static class Node<E> {
        E item;
        Node<E> next;
        Node(E x) { item = x; }
    }

2.变量与构造方法

    /** 链表容量 */
    private final int capacity;

    /** 队列中元素数 */
    private final AtomicInteger count = new AtomicInteger();

    /**
     * 头节点（head.item == null）
     */
    transient Node<E> head;

    /**
     * 尾节点（last.item == null）
     */
    private transient Node<E> last;

    /** 出队独占锁  用于take、poll方法中 */
    private final ReentrantLock takeLock = new ReentrantLock();

    /** 条件变量 take的阻塞队列 */
    private final Condition notEmpty = takeLock.newCondition();

    /** 入队独占锁  用于put、offer中 */
    private final ReentrantLock putLock = new ReentrantLock();

    /** 条件变量 put的阻塞队列 */
    private final Condition notFull = putLock.newCondition();

    public LinkedBlockingQueue() {
        this(Integer.MAX_VALUE);
    }

    public LinkedBlockingQueue(int capacity) {
        if (capacity <= 0) throw new IllegalArgumentException();
        this.capacity = capacity;
        last = head = new Node<E>(null);
    }

    public LinkedBlockingQueue(Collection<? extends E> c) {
        this(Integer.MAX_VALUE);
        final ReentrantLock putLock = this.putLock;
        putLock.lock(); // Never contended, but necessary for visibility
        try {
            int n = 0;
            for (E e : c) {
                if (e == null)
                    throw new NullPointerException();
                if (n == capacity)
                    throw new IllegalStateException("Queue full");
                enqueue(new Node<E>(e));
                ++n;
            }
            count.set(n);
        } finally {
            putLock.unlock();
        }
    }

3.方法

1）boolean offer(E e):非阻塞入队

    public boolean offer(E e) {
        //为空校验
        if (e == null) throw new NullPointerException();
        final AtomicInteger count = this.count;
        if (count.get() == capacity)
            //队列满，直接返回，非阻塞
            return false;
        int c = -1;
        Node<E> node = new Node<E>(e);
        //获取入队独占锁
        final ReentrantLock putLock = this.putLock;
        putLock.lock();
        try {
            if (count.get() < capacity) {
                //队列不满，元素入队
                enqueue(node);
                c = count.getAndIncrement();
                if (c + 1 < capacity)
                    //队列不满，唤醒notFull条件队列中的一个线程
                    notFull.signal();
            }
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            //队列为空时，唤醒notEmpty条件队列中的一个线程
            signalNotEmpty();
        return c >= 0;
    }

 2）void put(E e):阻塞入队

    public void put(E e) throws InterruptedException {
        if (e == null) throw new NullPointerException();
        // Note: convention in all put/take/etc is to preset local var
        // holding count negative to indicate failure unless set.
        int c = -1;
        Node<E> node = new Node<E>(e);
        final ReentrantLock putLock = this.putLock;
        final AtomicInteger count = this.count;
        //不忽略中断引起的返回
        putLock.lockInterruptibly();
        try {
            while (count.get() == capacity) {
                //队满时，当前线程入notFull条件队列
                notFull.await();
            }
            enqueue(node);
            c = count.getAndIncrement();
            if (c + 1 < capacity)
                //入队后，队列不满，唤醒因队满引起的阻塞线程（put方法引起）
                notFull.signal();
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            //队空时，唤醒因notEmpty条件队列中的一个阻塞线程
            signalNotEmpty();
    }

3）E poll():不阻塞出队

    public E poll() {
        final AtomicInteger count = this.count;
        if (count.get() == 0)
            //队列为空直接返回null，不入阻塞队列
            return null;
        E x = null;
        int c = -1;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lock();
        try {
            if (count.get() > 0) {
                x = dequeue();
                c = count.getAndDecrement();
                if (c > 1)
                    //队列不为空时，唤醒notEmpty条件队列中的一个线程
                    notEmpty.signal();
            }
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)
            //出队成功后，队满，欢迎notFull条件队列中的一个线程
            signalNotFull();
        return x;
    }

4)E take():阻塞出队

    public E take() throws InterruptedException {
        E x;
        int c = -1;
        final AtomicInteger count = this.count;
        final ReentrantLock takeLock = this.takeLock;
　　　　　//不忽略中断引起的返回，抛出异常
        takeLock.lockInterruptibly();
        try {
            while (count.get() == 0) {
                //队空时，入notEmpty条件阻塞队列，阻塞
                notEmpty.await();
            }
            x = dequeue();
            c = count.getAndDecrement();
            if (c > 1)
                //出队后，队不为空，唤醒notEmpty条件阻塞队列中的一个线程
                notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)
            //队满时，唤醒notFull条件阻塞队列中的一个线程
            signalNotFull();
        return x;
    }

5）E peek()非阻塞获取队首元素

    public E peek() {
        if (count.get() == 0)
            return null;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lock();
        try {
            Node<E> first = head.next;
            if (first == null)
                return null;
            else
                return first.item;
        } finally {
            takeLock.unlock();
        }
    }

6)boolean remove( Object o):删除队列中指定元素

    public boolean remove(Object o) {
        if (o == null) return false;
        //获取两个锁，takeLock及putLock，即会阻塞出入队操作
        fullyLock();
        try {
            for (Node<E> trail = head, p = trail.next;
                 p != null;
                 trail = p, p = p.next) {
                if (o.equals(p.item)) {
                    unlink(p, trail);
                    return true;
                }
            }
            return false;
        } finally {
            fullyUnlock();
        }
    }

7).int size():队列元素个数

    public int size() {
        return count.get();//takeLock和putLock已经保证了count的原子性
    }

4.总结

1）单链表实现，

2）读写分离策略，引入两个可重入独占锁takeLock（出队锁）和putLock（入队锁）

3）提供入队的非阻塞方法offer和阻塞方法put，队满，调用offer入队时直接丢弃，调用put入队时，线程入putLock的条件变量notFull的阻塞队列，offer、put、poll、take都会唤醒notFull的          阻塞队列中的线程

      另offer方法忽略中断引起的返回，put方法不忽略中断引起的返回，会抛出异常

4）提供出队的非阻塞方法poll和阻塞方法take，队空，调用poll出队时直接返回null，调用take出队时，线程入takeLock的条件变量notEmpty的阻塞队列，offer、put、poll、take都会唤醒            notEmpty的阻塞队列中的线程

      另poll方法忽略中断引起的返回，take方法不忽略中断引起的返回，会抛出异常

 5）remove操作会获取双重锁，即remove操作时，会阻塞其他出入队线程。

 6）两种阻塞：因获取Lock锁入AQS阻塞队列；获取Lock锁后，因队列满空入条件队列（生产消费模型）

三、ArrayBlockingQueue——有界阻塞队列（顺序存储）

 1.变量与构造方法

    /** 存放队列元素的数组——顺序存储 */
    final Object[] items;

    /** 队列头节点数组下标 items index for next take, poll, peek or remove */
    int takeIndex;

    /**  入队时入队元素存入的数组下标（尾节点数组下标+1，注意循环队列顺序实现） items index for next put, offer, or add */
    int putIndex;

    /** 队列中元素个数 Number of elements in the queue */
    int count;

    /*
     * 并发控制采用单锁双条件控制 
     */

    /**  Main lock guarding all access */
    final ReentrantLock lock;

    /** 出队时 队空，条件阻塞队列 Condition for waiting takes */
    private final Condition notEmpty;

    /** 入队时 队满，条件阻塞队列 Condition for waiting puts */
    private final Condition notFull;

    /**
     * 迭代器
     */
    transient Itrs itrs = null;

    public ArrayBlockingQueue(int capacity) {
        this(capacity, false);
    }

    /**构造方法初始化锁及条件变量*/
    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();
    }

    public ArrayBlockingQueue(int capacity, boolean fair,
                              Collection<? extends E> c) {
        this(capacity, fair);

        final ReentrantLock lock = this.lock;
        lock.lock(); // Lock only for visibility, not mutual exclusion
        try {
            int i = 0;
            try {
                for (E e : c) {
                    checkNotNull(e);
                    items[i++] = e;
                }
            } catch (ArrayIndexOutOfBoundsException ex) {
                throw new IllegalArgumentException();
            }
            count = i;
            putIndex = (i == capacity) ? 0 : i;
        } finally {
            lock.unlock();
        }
    }

2.方法

1)boolean offer(E e):非阻塞入队

    public boolean offer(E e) {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            if (count == items.length)
                //队满直接返回，未入条件阻塞队列--非阻塞
                return false;
            else {
                enqueue(e);
                return true;
            }
        } finally {
            lock.unlock();
        }
    }

    private void enqueue(E x) {
        final Object[] items = this.items;
        items[putIndex] = x;
        //数组实现的循环队列
        if (++putIndex == items.length)
            putIndex = 0;
        count++;
        //唤醒notEmpty条件阻塞队列中的一个线程
        notEmpty.signal();
    }

2）void put(E e):阻塞入队

    public void put(E e) throws InterruptedException {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        //不忽略中断引起的AQS阻塞队列的返回，抛出异常
        lock.lockInterruptibly();
        try {
            while (count == items.length)
                //队满入notFull条件阻塞队列--阻塞
                notFull.await();
            enqueue(e);
        } finally {
            lock.unlock();
        }
    }

3）E poll():非阻塞出队

    public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return (count == 0) ? null : dequeue();
        } finally {
            lock.unlock();
        }
    }

    private E dequeue() {
        final Object[] items = this.items;
        @SuppressWarnings("unchecked")
        E x = (E) items[takeIndex];
        items[takeIndex] = null;
        //数组实现的循环队列，头指针变化
        if (++takeIndex == items.length)
            takeIndex = 0;
        count--;
        if (itrs != null)
            //迭代器中元素出队
            itrs.elementDequeued();
        //唤醒notFull条件阻塞队列中的一个线程
        notFull.signal();
        return x;
    }

4）E take():阻塞出队

    public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        //不忽略中断引起的AQS阻塞队列中线程的返回
        lock.lockInterruptibly();
        try {
            while (count == 0)
                //队空时，入notEmpty条件阻塞队列--阻塞
                notEmpty.await();
            return dequeue();
        } finally {
            lock.unlock();
        }
    }        

5）E peek():非阻塞获取队首元素

    public E peek() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return itemAt(takeIndex); // null when queue is empty
        } finally {
            lock.unlock();
        }
    }

    final E itemAt(int i) {
        return (E) items[i];
    }

6）int size():当前队列中元素个数

    public int size() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return count;//加锁原因：count内存可见性(未被volatile修饰)
        } finally {
            lock.unlock();
        }
    }

三、总结

1.循环队列实现

2.单锁双条件变量的设计可能是由于读写操作的是同一个数组，与LinkedBlockingQueue双锁双条件变量区别，操作的是两个独立的节点

3）提供入队的非阻塞方法offer和阻塞方法put，队满，调用offer入队时直接丢弃，调用put入队时，线程入lock的条件变量notFull的阻塞队列，poll、take都会唤醒notFull的阻塞队列中的线程，另offer方法忽略中断引起的返回，put方法不忽略中断引起的返回，会抛出异常

4）提供出队的非阻塞方法poll和阻塞方法take，队空，调用poll出队时直接返回null，调用take出队时，线程入takeLock的条件变量notEmpty的阻塞队列，offer、put都会唤醒notEmpty的阻塞队列中的线程，另poll方法忽略中断引起的返回，take方法不忽略中断引起的返回，会抛出异常

5）size方法加锁，比LinkedBlockingQueue的size方法更加精确

6）两种阻塞：因获取Lock锁入AQS阻塞队列；获取Lock锁后，因队列满空入条件队列（生产消费模型）,（循环队列，将数据画成圆形比较好，后补）

四、PriorityBlockingQueue——优先级无界阻塞队列（顺序存储、堆实现）

顺序存储实现的平衡二叉树堆结构，用堆来实现优先级，涉及比较所以元素需要实现Comparable接口

1、变量与构造方法

    /**
     * 默认队列大小
     */
    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;

    /**
     * 默认构造*/
    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();
    }

 2、常用方法

1）由于是无界队列所以元素入队不存在阻塞，offer(E e),put(E e)都是非阻塞的

    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)
                //比较器为空默认元素e.compareTo(array[])，建堆与入堆调整
                siftUpComparable(n, e, array);
            else
                //比较器compareTo(e,array[])，建堆与入堆调整
                siftUpUsingComparator(n, e, array, cmp);
            size = n + 1;
            //入队成功，唤醒notEmpty条件阻塞队列中的一个线程
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
        return true;
    }

2）E poll():非阻塞出队

    public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return dequeue();
        } finally {
            lock.unlock();
        }
    }

    private E dequeue() {
        int n = size - 1;
        if (n < 0)
            return null;
        else {
            Object[] array = queue;
            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;
        }
    }

3）E take():阻塞出队

    public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        //不忽略中断引起的AQS阻塞队列的返回，会抛出异常
        lock.lockInterruptibly();
        E result;
        try {
            while ( (result = dequeue()) == null)
                //队列为空，入notEmpty条件阻塞队列
                notEmpty.await();
        } finally {
            lock.unlock();
        }
        return result;
    }

4）E peek():非阻塞获取队首元素

    public E peek() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return (size == 0) ? null : (E) queue[0];
        } finally {
            lock.unlock();
        }
    }

5）int size():获取队列中元素个数

    public int size() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return size;
        } finally {
            lock.unlock();
        }
    }

3.两个重要的实现方法

1）数组扩容方法tryGrow

    private void tryGrow(Object[] array, int oldCap) {
         //扩容时先释放锁，不释放会导致扩容线程扩容期间，其他线程操作会阻塞
        lock.unlock(); // must release and then re-acquire main lock
        Object[] newArray = null;
        //allocationSpinLock标识实现自旋锁，1表示正在扩容
        if (allocationSpinLock == 0 &&
            UNSAFE.compareAndSwapInt(this, allocationSpinLockOffset,
                                     0, 1)) {
            try {
                //扩容策略①当前数组大小小于64时 newCap = 2 * oldCap + 2
                //扩容策略②当前数组大小不小于64时 newCap = 1.5 * oldCap
                int newCap = oldCap + ((oldCap < 64) ?
                                       (oldCap + 2) : // grow faster if small
                                       (oldCap >> 1));
                if (newCap - MAX_ARRAY_SIZE > 0) {    // possible overflow
                    //先数组newCap大于扩容最大值，oldCap+1还是溢出的话抛出异常，否则newCap = 最大容量
                    int minCap = oldCap + 1;
                    if (minCap < 0 || minCap > MAX_ARRAY_SIZE)
                        throw new OutOfMemoryError();
                    newCap = MAX_ARRAY_SIZE;
                }
                //扩容期间 数组被其他线程修改，扩容失败，offer方法中while循环重试
                if (newCap > oldCap && queue == array)
                    newArray = new Object[newCap];
            } finally {
                allocationSpinLock = 0;
            }
        }
        if (newArray == null) //正在扩容时，其他线程让出CPU 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);
        }
    }

2）堆实现

建堆方法siftUpComparable

    private static <T> void siftUpComparable(int k, T x, Object[] array) {
        Comparable<? super T> key = (Comparable<? super T>) x;
        while (k > 0) {
            int parent = (k - 1) >>> 1;
            Object e = array[parent];
            if (key.compareTo((T) e) >= 0)
                break;
            array[k] = e;
            k = parent;
        }
        array[k] = key;
    }

例子：入堆序列15324，小顶堆

 

堆顶元素出堆siftDownComparable

    private static <T> void siftDownComparable(int k, T x, Object[] array,
                                               int n) {
        if (n > 0) {
            Comparable<? super T> key = (Comparable<? super T>)x;
            int half = n >>> 1;           // loop while a non-leaf
            while (k < half) {
                int child = (k << 1) + 1; // assume left child is least
                Object c = array[child];
                int right = child + 1;
                if (right < n &&
                    ((Comparable<? super T>) c).compareTo((T) array[right]) > 0)
                    c = array[child = right];
                if (key.compareTo((T) c) <= 0)
                    break;
                array[k] = c;
                k = child;
            }
            array[k] = key;
        }
    }

例子：入堆序列15324，小顶堆出堆

 

 4、总结

1.顺序存储，二叉平衡树堆实现

2.由于是无界的所以仅有一个条件变量notEmpty，单锁单条件变量

3）入堆方法offer、put是非阻塞的（无notFull）

4）提供出队的非阻塞方法poll和阻塞方法take，队空，调用poll出队时直接返回null，调用take出队时，线程入lock的条件变量notEmpty的阻塞队列，offer、put都会唤醒notEmpty的阻塞队列中的线程，另poll方法忽略中断引起的返回，take方法不忽略中断引起的返回，会抛出异常

5）无界阻塞队列，所以存在扩容机制；用自旋锁保证扩容时的线程安全；扩容策略：

①oldCap<64时newCap = 2*oldCap +2；oldCap>=64时newCap = 1.5*oldCap；

②newCap>maxCap时oldCap+1>maxCap抛错；否则newCap=maxCap;

6）建堆与堆调整是《数据结构》中堆排序算法的简化。

7）两种阻塞：因获取Lock锁入AQS阻塞队列；获取Lock锁后，因队列空入条件队列（生产消费模型）,数组中的元素不再是固定的，每次入队出队都会进行堆调整

五、DelayQueue——无界阻塞延时队列

 采用PriorityQueue存储元素，延时队列故元素必须有个过期时间（必须实现Delayed接口）

public interface Delayed extends Comparable<Delayed> {
    long getDelay(TimeUnit unit);
}

1、变量与构造方法

    private final transient ReentrantLock lock = new ReentrantLock();
    private final PriorityQueue<E> q = new PriorityQueue<E>();

    /**
     * leader-follower线程模型的变体*/
    private Thread leader = null;

    /**
     * 争取leader线程的阻塞队列
     */
    private final Condition available = lock.newCondition();

    public DelayQueue() {}

    public DelayQueue(Collection<? extends E> c) {
        this.addAll(c);
    }

2、方法

1）无界队列，offer()、put()是非阻塞方法

    public boolean offer(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            q.offer(e);
            if (q.peek() == e) {
                //元素入队且位于队首；由于leader线程与队首元素有关，队首元素改变了，需要重新设置
                leader = null;
                available.signal();
            }
            return true;
        } finally {
            lock.unlock();
        }
    }

2）E poll()：非阻塞出队；E peek()：获取队首元素

    public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            E first = q.peek();
            if (first == null || first.getDelay(NANOSECONDS) > 0)
                //没有过期元素时，直接返回——非阻塞
                return null;
            else
                return q.poll();
        } finally {
            lock.unlock();
        }
    }

    public E peek() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return q.peek();
        } finally {
            lock.unlock();
        }
    }

3）E take()：阻塞出队

    public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            for (;;) {
                E first = q.peek();
                if (first == null)
                    //队列为空，入条件阻塞队列  和前面的notEmpty一样
                    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)
                        //leader线程不为空，当前线程为followed线程入条件阻塞队列  比notEmpty多行使的职责
                        available.await();
                    else {
                        //leader线程为空，设置当前线程为leader线程
                        Thread thisThread = Thread.currentThread();
                        leader = thisThread;
                        try {
                            //leader线程入条件阻塞队列，有效期为过期时间，
                            //此时入队线程会被lock阻塞入AQS阻塞队列，出队线程会被leader线程阻塞，进入available条件阻塞队列
                            available.awaitNanos(delay);
                        } finally {
                            //过期时间到，取消leader线程，线程出队
                            if (leader == thisThread)
                                leader = null;
                        }
                    }
                }
            }
        } finally {
            if (leader == null && q.peek() != null)
                //出队成功后  leader线程为空且队列不为空，唤醒其他出队线程（followed线程）
                available.signal();
            lock.unlock();
        }
    }

3.总结

1）.由优先级队列PriorityQueue存储数据，PriorityQueue是java.util下的集合，不是线程安全的，用独占锁保证线程安全；入队元素需要实现Delayed接口

2）.单锁单条件变量available；这里的条件变量available两种情景

①队列为空时，take出队线程入条件阻塞队列（与notEmpty场景一致）

②队列不为空时，take出队但没有过期元素，入条件阻塞队列

3）.leader-followed线程模型的简易变体，队列不为空且多个take线程但没有过期元素，线程全部入条件阻塞队列，并会设置一个线程为leader线程，其他线程为followed线程；

leader线程由于awaitNanos（delay）出队成功后会唤醒其他followed线程；争取leader线程

4）两种阻塞：因获取Lock锁入AQS阻塞队列；获取Lock锁后，因队列空或没有过期元素入条件队列（生产消费模型）

 4、实例

public class DelayQueueTest {

    public static void main(String[] args){
        DelayQueue<DelayedEle> delayQueue = new DelayQueue<>();
        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            DelayedEle ele = new DelayedEle(random.nextInt(500), "task" + i);
            delayQueue.offer(ele);
        }
        DelayedEle eleTake = null;
        try {
            for (;;){
                while ((eleTake = delayQueue.take()) != null){
                    System.out.println(eleTake.toString());
                }
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }

    static class DelayedEle implements Delayed {

        private final long delayTime;
        private final long expire;
        private String taskName;

        public DelayedEle(long delayTime, String taskName){
            this.delayTime = delayTime;
            this.taskName = taskName;
            this.expire = System.currentTimeMillis() + delayTime;
        }

        @Override
        public long getDelay(TimeUnit unit) {
            return unit.convert(this.expire - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
        }

        @Override
        public int compareTo(Delayed o) {
            return (int) (this.getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS));
        }

        @Override
        public String toString() {
            final StringBuilder sb = new StringBuilder("DelayedEle{");
            sb.append("delay=").append(delayTime);
            sb.append(", expire=").append(expire);
            sb.append(", taskName=").append(taskName);
            sb.append("}");
            return sb.toString();
        }
    }

}

参考自《java并发编程之美》