JAVA并发包（十）：LinkedBlockingQueue

LinkedBlockingQueue中文名叫链表阻塞队列，内部是链表结构，拥有先进先出的特性。说的阻塞的特性，是当队列满的时候插入元素会阻塞掉线程知道队列有空余位置，当队列为空的时候取出元素会阻塞直到队列有元素为止。
LinkedBlockingQueue是BlockingQueue接口的实现类，我们首先来看看BlockingQueue接口。

一、BlockingQueue

BlockingQueue大概有5个实现类，分别如下：

1. ArrayBlockingQueue
2. LinkedBlockingQueue
3. SynchronousQueue
4. PriorityBlockingQueue
5. DelayQueue

这些实现类都实现了接口定义的特殊方法，这些方法有如下几个：

1. 入队列方法

add()：有足够空间时会立刻插入，当空间不足时抛出IlleagalStateException异常
offer()：有足够空间时会立刻插入，当空间不足时返回失败。
put()：有足够空间时会立刻插入，当空间不足时阻塞等待有足够空间再插入。
offer(E e, long timeout, TimeUnit unit)：有足够空间时会立刻插入，当空间不足时等待给定的时间，如果还是时间到了还是没有足够空间插入就返回失败。

2. 出队列方法

take()：取出队列头的元素（取出后队列删除这个元素），当队列没有元素可取时阻塞等待。
remove（）：没有元素可取时抛出异常
poll(long timeout, TimeUnit unit)：取出队列头的元素（取出后队列删除这个元素），当队列中没有元素可取时，阻塞等待给定的时间，到了时间还是不可取时返回null
poll()：立即取出队列头的元素（取出后队列移除这个元素）,队列为空时返回null。

3. 窥视方法

peek() :返回队列头的元素，但是不会在队列中移除。队列为空时返回null。
element（）：队列为空时抛出异常

二、LInkedBlockingQueue内部结构

public class LinkedBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable {
	// 构造器，默认容量是int的最大值
	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) {
		// 里面代码省略，其实就是把入参的集合加到队列里
    }

	/** 队列容量，默认是int最大值 */
    private final int capacity;

    /** AtomicInteger记录当前队列的大小 */
    private final AtomicInteger count = new AtomicInteger();

    /**
     * 队列的头节点，head.item都是为空，第一个节点为head.next.item
     */
    transient Node<E> head;

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

    /** 获取节点的锁 */
    private final ReentrantLock takeLock = new ReentrantLock();

    /** 获取元素的等待队列 */
    private final Condition notEmpty = takeLock.newCondition();

    /** 插入节点的锁 */
    private final ReentrantLock putLock = new ReentrantLock();

    /** 插入节点的等待队列 */
    private final Condition notFull = putLock.newCondition();
	
	/** 节点对象 */
	static class Node<E> {
        E item;
        Node<E> next;
        Node(E x) { item = x; }
    }
}

三、入队列方法

首先来看看会阻塞的入队列方法

public void put(E e) throws InterruptedException {
        if (e == null) throw new NullPointerException();
        // 默认队列大小是-1，代表操作失败
        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) {
            	// await方法是释放锁，然后阻塞，当被唤醒的时候会再次获取锁
                notFull.await();
            }
            // 入队列
            enqueue(node);
            c = count.getAndIncrement();
            // 入队列后队列还没满的话，唤醒等待入队列的线程
            if (c + 1 < capacity)
                notFull.signal();
        } finally {
            putLock.unlock();
        }
        // 如果c为0说明操作入队列之前队列为空，此时队列有一个元素了，那么唤醒等待获取元素的线程去获取元素
        if (c == 0)
            signalNotEmpty();
    }

非阻塞入队列方法

	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.signal();
            }
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            signalNotEmpty();
        return c >= 0;
    }

三、出队列方法

阻塞方法

public E take() throws InterruptedException {
        E x;
        int c = -1;
        final AtomicInteger count = this.count;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lockInterruptibly();
        try {
        	// 注意这里用了while轮询，而不是if，如果队列大小为0的话会一直阻塞线程
            while (count.get() == 0) {
                notEmpty.await();
            }
            x = dequeue();
            c = count.getAndDecrement();
            // c大于1说明队列中还有元素可以获取，那么唤醒等待获取的线程
            if (c > 1)
                notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
        // 如果出队列之前的队列大小为最大容量，那么一个元素出队列之后就有了剩余空间 ，可以唤醒等待入队列的线程
        if (c == capacity)
            signalNotFull();
        return x;
    }

非阻塞方法

public E poll() {
        final AtomicInteger count = this.count;
        if (count.get() == 0)
            return null;
        E x = null;
        int c = -1;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lock();
        try {
        	// 加锁之后判断队列是否为空，不为空就直接获取元素，然后队列容量减去1
            if (count.get() > 0) {
                x = dequeue();
                c = count.getAndDecrement();
                if (c > 1)
                    notEmpty.signal();
            }
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)
            signalNotFull();
        return x;
    }

四、窥视方法

窥视方法很好理解，就是查看head.next.item，值得注意的是这里也做了加锁

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

五、清除操作

我们在讲解线程池的shutdownNow()时遇到了清除方法drainTo()，把等待任务队列的任务全部转移到入参集合里，下面来看看它的实现原理

	public int drainTo(Collection<? super E> c) {
        return drainTo(c, Integer.MAX_VALUE);
    }

	public int drainTo(Collection<? super E> c, int maxElements) {
        if (c == null)
            throw new NullPointerException();
        if (c == this)
            throw new IllegalArgumentException();
        if (maxElements <= 0)
            return 0;
        boolean signalNotFull = false;
        final ReentrantLock takeLock = this.takeLock;
        // 这里加获取元素的锁，不允许其他线程取数
        takeLock.lock();
        try {
            int n = Math.min(maxElements, count.get());
            // count.get provides visibility to first n Nodes
            Node<E> h = head;
            int i = 0;
            try {
            	// 从头节点开始取元素
                while (i < n) {
                    Node<E> p = h.next;
                    // 元素加到集合里
                    c.add(p.item);
                    // 然后清除该节点的元素
                    p.item = null;
                    // 这里可以理解是断开连接
                    h.next = h;
                    h = p;
                    ++i;
                }
                return n;
            } finally {
                // i大于0说明有清除节点
                if (i > 0) {
                    // 清除多少算多少，不一定全部清除掉了，即h不一定是null
                    head = h;
                    // 队列大小减去清除的数量
                    signalNotFull = (count.getAndAdd(-i) == capacity);
                }
            }
        } finally {
            takeLock.unlock();
            // 唤醒等待入队列的线程
            if (signalNotFull)
                signalNotFull();
        }
    }

六、总结

从上面的源码分析中可以看出，LinkedBlockingQueue通过原子类count的大小来控制队列允许的操作。当count等于最大容量时，不允许插入操作。当count等于0时，不予许出队列操作。

入队列和出队列各自维护一把重入锁，当不允许操作时会阻塞线程。

迭代器和删除的方法这里就不做研究了，一般情况下也不会使用到这两个方法。