Java并发（三）：并发容器之BlockingQueue

CopyOnWriteArraySet
CopyOnWriteArrayList
BlockingQueue
ArrayBlockingQueue
ConcurrentLinkedQueue

BlockingQueue
　　BlockingQueue是阻塞队列的顶级接口，定义了一系列的API，主要声明了在获取元素时等待队列变为非空，以及在存储元素时等待空间变得可用这两个特点。
　　BlockingQueue队列不接受 null 元素，试图插入一个 null 元素时，某些实现会抛出 NullPointerException。此外该类的实现是线程安全的，且主要用作生产者-使用者队列。
　　API如下（摘自JDK文档中的一部分） 

方法摘要
boolean	add(E e)           将指定的元素插入此队列（如果立即可行且不会违反容量限制），在成功时返回 true，如果当前没有可用的空间，则抛出 IllegalStateException。
E	element()           获取，但是不移除此队列的头。
boolean	offer(E e)           将指定的元素插入此队列（如果立即可行且不会违反容量限制），当使用有容量限制的队列时，此方法通常要优于 add(E)，后者可能无法插入元素，而只是抛出一个异常。
E	peek()           获取但不移除此队列的头；如果此队列为空，则返回 null。
E	poll()           获取并移除此队列的头，如果此队列为空，则返回 null。
E	remove()           获取并移除此队列的头。

LinkedBlockingQueue
　　一个链表结构的有界阻塞队列，也可以说无界，因为默认容量为Integer.MAX_VALUE，基本上达不到，其内部维护了一个基于Node链表，只要容量未达到Integer.MAX_VALUE，就可以一直扩展，当然也可以在构造时指定容量。主要特点可归纳如下

• 先进先出，新添加的元素位于尾部，获取操作取出头部元素
• 通过可重入锁ReentrantLock + Condition条件来实现生产—消费模式下的同步控制，保证安全性
• 对于put 与 take，分别提供了各自ReentrantLock，所以put 与 take之间在锁上面不会产生阻塞，而是在条件上面。
• 相较于ArrayBlockingQueue来说，吞吐量通常要高于基于数组的队列

其源码也比较简单，以1.8为例，主要的属性及构造器如下

    // 头节点
    transient Node<E> head;

    // 尾节点
    private transient Node<E> last;

    /** 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();

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

add(E e) / put(E e)  /offer(E e)主要区别

• 队列已满时，offer操作立即返回false，put操作则挂起当前线程，等待队列空间变得可用；
  而add(E e)是对offer的包装，当offer返回false后，add抛出一个异常。
• put在获取锁putLock.lockInterruptibly()之前或过程中可以响应中断的，线程被中断的情况下会抛出中断异常，而offer中 putLock.lock();是不响应中断的，会一直等到成功获取锁。

　　在队列空间足够的情况，都会将元素添加链表尾部，添加后，如果队列仍然未达最大容量，则执行notFull.signal()唤醒一个处于等待中的生产线程（等待队列被消费）；如果队列为空，则添加后执行notEmpty.signal()唤醒一个处于等待中的消费线程（等待队列不为空）。

public boolean add(E e) {
    if (offer(e))
        return true;
    else
        throw new IllegalStateException("Queue full");
}
public void put(E e) throws InterruptedException {
        if (e == null) throw new NullPointerException();
       
        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.await();
            }
           // 否则，将元素添加到队列尾部
            enqueue(node);
            c = count.getAndIncrement();
           
           // 添加元素后，如果队列仍未满，则唤醒后续生产者，继续添加。
            if (c + 1 < capacity)
                notFull.signal();
        } finally {
            putLock.unlock();
        }
        // 如果队列为空，则添加元素后，执行notEmpty.signal()唤醒一个消费者
        if (c == 0)
            signalNotEmpty();
    }

 private void enqueue(Node<E> node) {
        // assert putLock.isHeldByCurrentThread();
        // assert last.next == null;
        last = last.next = node;
    }

 private void signalNotEmpty() {
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lock();
        try {
            notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
    }

take()/poll()/peek()的主要区别

• take在队列为空时，会挂起当前线程，直到队列中有可用数据，而poll则立即返回null。
• 同样的take在获取锁 takeLock.lockInterruptibly()之前或过程中，可以响应中断，而poll获取锁的方式takeLock.lock()会直到锁成功获取。
• peek()只获取但不删除此队列的头，如果此队列为空，则返回 null 

元素取完之后，如果队列中仍有元素，则唤醒一个处于等待中的消费线程（等待队列有可用数据）；如果是在队列满状态的情况下取走一个，则调用notFull.signal()唤醒一个处于等待中的生产线程（等待队列被消费）

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

            // 否则获取并移除头部元素
            x = dequeue();
            c = count.getAndDecrement();

            // 取完之后，如果队列中仍有元素，则唤醒后续其它消费线程
            if (c > 1)
                notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
        // 如果队列满了，则取走一个之后，则调用notFull.signal()唤醒一个生产方
        if (c == capacity)
            signalNotFull();
        return x;
    }

 private E dequeue() {
        // assert takeLock.isHeldByCurrentThread();
        // assert head.item == null;
        Node<E> h = head;
        Node<E> first = h.next;
        h.next = h; // help GC
        head = first;
        E x = first.item;
        first.item = null;
        return x;
    }

 private void signalNotFull() {
        final ReentrantLock putLock = this.putLock;
        putLock.lock();
        try {
            notFull.signal();
        } finally {
            putLock.unlock();
        }
    }

remove()：takeLock与putLock同时锁定

public boolean remove(Object o) {
        if (o == null) return false;
        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();
        }
    }

迭代队列：迭代过程中，同样阻塞所有put和take操作，即putLock和takeLock同时会被占用。

 public Iterator<E> iterator() {
        return new Itr();
    }

    private class Itr implements Iterator<E> {
        private Node<E> current;
        private Node<E> lastRet;
        private E currentElement;

        Itr() {
            // take与put同时锁住
            fullyLock();  
            try {
                current = head.next;
                if (current != null)
                    currentElement = current.item;
            } finally {
                fullyUnlock();
            }
        }

        public boolean hasNext() {
            return current != null;
        }
...
void fullyLock() {
        putLock.lock();
        takeLock.lock();
    }

ArrayBlockingQueue
　　一个数组结构的有界阻塞队列，底层维护了一个Object[]数组来存储元素，该数组在创建后就不会再增加其容量，数组满了后添加操作会受阻塞，数组为空时提取操作将受阻塞。与LinkedBlockQueue的主要区别在于

• 底层数据结构不一样，该类底层为数组，LinkedBlockQueue底层为链表结构
• ArrayBlockingQueue只包含一个锁，所以添加、获取操作之间会在ReentrantLock锁上产生阻塞；
  而LinkedBlockQueue对于添加和获取分别提供了一个ReentrantLock，添加、获取之间不会在ReentrantLock锁上产生竞争，而是在队列已满或为空的情况下，在条件Condition上 产生阻塞；
  所以理论上来说LinkedBlockQueue吞吐量一般高于ArrayBlockingQueu这种数组结构。
• ArrayBlockingQueu的锁可设置成公平锁或非公平锁（默认使用非公平锁），给等待中的生产线程或消费线程 分配锁时，如果采用公平锁，则会尽量保证按FIFO顺序调起线程，所以公平锁的情况下通常会降低吞吐量，但也减少了可变性和避免了“不平衡性”。

　　关于公平锁与非公平锁在以前的博客中有过说明，这里简单再介绍，公平锁更倾向于（但并不保证）优先将锁分配给等待时间最长的线程，对应这里就是先进的先执行（对应FIFO），非公平锁就是锁可用的情况下随机分配，有的线程可能很久都获取不到，而有的线程经常获取。

public class ArrayBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable {   

    /** The queued items */
    final Object[] items;

    /** 该值=提取元素下标+1, 表示下个元素（即头部元素）所处下标 */
    int takeIndex;

    /** 该值=添加元素的下标+1，表示下个元素存放下标*/
    int putIndex;

    /** 队列中元素的个数，通过比较该值与items.length来判断是空或已满 */
    int count;

    // 一个锁+两个条件
    final ReentrantLock lock;    
    private final Condition notEmpty;
    private final Condition notFull;
  
    transient Itrs itrs = null;

add(E e) / put(E e)  /offer(E e)主要区别

• 队列已满时，offer返回false，而put()会等待直到队列可用，add只是对offer包装，当offer()返回false时，add抛出异常。
• 同LinkedBlockingQueue一样，put在获取锁lock.lockInterruptibly()之前或过程中也可以响应中断的，线程被中断的情况下会抛出中断异常，而offer中 lock.lock();是不响应中断的，会一直等到成功获取锁。

public void put(E e) throws InterruptedException {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == items.length)
                notFull.await();
            enqueue(e);
        } finally {
            lock.unlock();
        }
    }
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();
        }
    }

take()/poll()/peek()

• 队列为空时，take挂起当前线程，直到队列中有可用数据；poll/peek都返回null。
• 同样的take在获取锁 lock.lockInterruptibly()之前或过程中，可以响应中断，而poll获取锁的方式lock.lock()会直到锁成功获取。
• peek()只获取但不删除此队列的头，如果此队列为空，则返回 null 

 public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == 0)
                notEmpty.await();
            return dequeue();
        } finally {
            lock.unlock();
        }
    }
public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return (count == 0) ? null : dequeue();
        } finally {
            lock.unlock();
        }
    }
public E peek() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return itemAt(takeIndex); // null when queue is empty
        } finally {
            lock.unlock();
        }
    }