阻塞队列BlockQueue

 先上BlockQueue的源码：

public interface BlockingQueue<E> extends Queue<E> {

    //增加一个元索 如果队列已满，则抛出一个IIIegaISlabEepeplian异常
    boolean add(E e);

    //添加一个元素并返回true 如果队列已满，则返回false
    boolean offer(E e);

    //添加一个元素 如果队列满，则阻塞
    void put(E e) throws InterruptedException;

    boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException;

    //移除并返回队列头部的元素 如果队列为空，则阻塞
    E take() throws InterruptedException;

    //移除并返问队列头部的元素 如果队列为空，则返回null
    E poll(long timeout, TimeUnit unit)
        throws InterruptedException;

    //剩余容量
    int remainingCapacity();

    //移除并返回队列头部的元素 如果队列为空，则抛出一个NoSuchElementException异常
    boolean remove(Object o);

    public boolean contains(Object o);

    //一次性从BlockingQueue获取所有可用的数据对象并转移到参数集合中
    int drainTo(Collection<? super E> c);

    int drainTo(Collection<? super E> c, int maxElements);
}

可以看到，BlockQueue提供了很多不同于其他集合的方法。下面是它的子类：

我们随便选一个ArrayBlockQueue来探索一下它是怎么做到阻塞的。先看看它的三个构造方法：

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

搜嘎，看到了没，我们关注的重点当然是第三个构造方法，此处用到了lock锁来把一个普通的集合转移到ArrayBlockQueue中。ArrayBlockQueue的初始化是在第二个构造方法中完成的。需要注意的是，ArrayBlockQueue内部存储对象的方式是通过Object数组实现的。

不难想象，构造方法就已经用lock锁来达到安全的目的了，那么，其他的阻塞相关方法也肯定离不开lock锁的影子了。我们带着这个flag继续往下走。先来看看offer()方法：

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

果然，被自己的帅气征服了下。为了避免被打脸，我们再找几个验证下：

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

恩....幸好，没有被打脸。到这里，我们就揭开BlockQueue的神秘面纱啦。