LinkedBlockingQueue源码分析（JDK8）

本文分析LinkedBlockingQueue的源码，学习其底层实现。

你可以通过我的这篇文章《阻塞队列BlockingQueue（JDK8）》了解阻塞队列的基本使用及各个方法的对比分析。

本文链接：http://blog.csdn.net/u010887744/article/details/73010691

LinkedBlockingQueue特性及使用场景：

1. 基于链表实现，线程安全的阻塞队列。
2. “two lock queue”算法变体，双锁（ReentrantLock）：takeLock、putLock，允许读写并行，remove(e)和迭代器iterators需要获取2个锁。
3. FIFO先进先出模式。
4. 在大部分并发场景下，LinkedBlockingQueue的吞吐量比ArrayBlockingQueue更好。

LinkedBlockingQueue应注意：

1、LinkedBlockingQueue默认为无界队列，即大小为Integer.MAX_VALUE，如果消费者速度慢于生产者速度，可能造成内存空间不足，建议手动设置队列大小。

概述LinkedBlockingQueue：

1. 队列头head是存在于队列中最久的元素，队尾tail是最新加入队列的元素。
2. 每次插入操作都将动态构造Linked nodes。
3. publicclass LinkedBlockingQueue<E>extendsAbstractQueue<E>implements BlockingQueue<E>, java.io.Serializable。
4. AbstractQueue：提供Queue必须实现的方法，add(e)、remove()、element()、clear()、addAll(c)。

1、LinkedBlockingQueue重要属性

• private final intcapacity：队列容量，创建时指定，默认Integer.MAX_VALUE。
• private final AtomicIntegercount= new AtomicInteger()：队列实际元素个数，size()方法返回count值。
• 【重要】private finalReentrantLocktakeLock= new ReentrantLock()：控制取数据的锁；putLock：控制存放数据的锁。
• 【重要】private finalConditionnotEmpty= takeLock.newCondition()：出队条件（takeLock锁的条件），队列为空时，通过此Condition让获取元素的线程等待；notFull：入队条件（putLock）。
• static class Node<E>：链表Node节点

static class Node<E> {
    E item; // 数据
    Node<E> next; // 下一个节点的指针，默认为null意味为最后一个节点，无后继
    Node(E x) { item = x; }
}

2、LinkedBlockingQueue构造函数

• LinkedBlockingQueue()：初始化容量为Integer.MAX_VALUE的队列；
• LinkedBlockingQueue(int capacity)：指定队列容量并初始化头尾节点，if (capacity <= 0) throw new IllegalArgumentException();last = head = new Node<E>(null)。
• LinkedBlockingQueue(Collection<? extends E> c)：初始化一个容量为Integer.MAX_VALUE且包含集合c所有元素的队列，且阻塞队列的迭代顺序同集合c。若集合c元素包含null，将throwNullPointerException；若集合c元素个数达到Integer.MAX_VALUE，将throwIllegalStateException("Queue full")。

---

// 将node链接到队列尾部
private void enqueue(Node<E> node) { // 入队
    // assert putLock.isHeldByCurrentThread();
    // assert last.next == null;
    last = last.next = node; // 等价于last.next = node;last = last.next(即node)
}
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)); // 执行last = last.next = node;
            ++n;
        }
        count.set(n); // 设置队列元素个数
    } finally {
        putLock.unlock();
    }
}

---

3、添加方法

先看几个重要方法：

/**
* 唤醒notEmpty上正在等待获取元素的线程
*/
private void signalNotEmpty() {
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lock();
    try {
        notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
}

3.1、offer(e)

// 队列已满:false
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(); // 获取插入锁putLock
    try {
        if (count.get() < capacity) { // 加锁后再次判断队列是否已满
            enqueue(node); // 入队
            c = count.getAndIncrement(); // 返回Inc之前的值
            if (c + 1 < capacity) // 插入节点后队列未满
                notFull.signal(); // 唤醒notFull上的等待线程
        }
    } finally {
        putLock.unlock(); // 释放插入锁
    }
    if (c == 0)
        signalNotEmpty(); // 如果offer前队列为空，则唤醒notEmpty上的等待线程
    return c >= 0;
}

衍生方法：

public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException {}

此方法和offer(E e)代码和功能均相似，但是如果在指定时间内未插入成功则会返回false。

比offer(E e)多的部分代码分析：

long nanos = unit.toNanos(timeout);  //将指定的时间长度转换为毫秒来进行处理
while (count.get() == capacity) {
    if (nanos <= 0) // 等待的剩余时间小于等于0，那么直接返回false
        return false;
    nanos = notFull.awaitNanos(nanos); // 最多等待时间（纳秒）
}

long awaitNanos(long nanosTimeout) throws InterruptedException;

指定时间内收到signal()或signalALL()则返回nanosTimeout减去已经等待的时间；若指定时间内有其它线程中断该线程，则抛出InterruptedException并清除当前线程的打断状态；若指定时间内未收到通知，则返回0或负数。

3.2、add(e)

调用AbstractQueue的add(E e)方法。

public boolean add(E e) {
    if (offer(e))
        return true;
    else
        throw new IllegalStateException("Queue full");
}

衍生方法：

booleanaddAll(Collection<? extends E> c)：（属于AbstractQueue类）循环调用add(E e)方法，内部结构为foreach遍历add(e)，所以可能部分数据插入成功，部分插入失败。

3.3、put(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;
 // 可中断的锁获取操作（优先考虑响应中断），如果线程由于获取锁而处于Blocked状态时，线程将被中断而不再继续等待（throws InterruptedException），可避免死锁。
    putLock.lockInterruptibly();
    try {
        /*
         * Note that count is used in wait guard even though it is
         * not protected by lock. This works because count can
         * only decrease at this point (all other puts are shut
         * out by lock), and we (or some other waiting put) are
         * signalled if it ever changes from capacity. Similarly
         * for all other uses of count in other wait guards.
         */
// 队列若满线程将处于等待状态。while循环可避免“伪唤醒”（线程被唤醒时队列大小依旧达到最大值）
        while (count.get() == capacity) {
            notFull.await(); // notFull：入队条件
        }
        enqueue(node); // 将node链接到队列尾部
        c = count.getAndIncrement(); // 元素入队后队列元素总和
        if (c + 1 < capacity) // 队列未满
            notFull.signal(); // 唤醒其他执行入队列的线程
    } finally {
        putLock.unlock(); // 释放锁
    }
// c=0说明队列之前为空，出队列线程均处于等待状态。添加一个元素后，队列已不为空，于是唤醒等待获取元素的线程
    if (c == 0)
        signalNotEmpty();
}

Note：lock 与 lockInterruptibly区别

①lock优先考虑获取锁，待获取锁成功后，才响应中断。

②lockInterruptibly 优先考虑响应中断，而不是响应锁的普通获取或重入获取。

详细区别：

ReentrantLock.lockInterruptibly允许在等待时由其它线程调用等待线程的Thread.interrupt方法来中断等待线程的等待而直接返回，这时不用获取锁，而会抛出一个InterruptedException。

ReentrantLock.lock方法不允许Thread.interrupt中断,即使检测到Thread.isInterrupted,一样会继续尝试获取锁，失败则继续休眠。只是在最后获取锁成功后再把当前线程置为interrupted状态,然后再中断线程。

LinkedBlockingQueue插入数据小结：

线程A入队操作前会获取putLock锁，插入数据完毕后释放；

队列未满将新建Node节点，添加到队列末尾；

队列已满则阻塞线程（notFull.await()）或返回false；若线程B取出数据，则会调用notFull.signal()唤醒notFull上的等待线程（线程A继续插数据）。

若入队前队列为空，则唤醒notEmpty上等待的获取数据的线程。

4、获取方法

先看几个重要方法：

/**
 * 唤醒等待插入数据的线程. Called only from take/poll.
 */
private void signalNotFull() {
    final ReentrantLock putLock = this.putLock;
    putLock.lock();
    try {
        notFull.signal();
    } finally {
        putLock.unlock();
    }
}
/**
* 队列头部元素出队.
*
* @return the node
*/
private E dequeue() {
    // assert takeLock.isHeldByCurrentThread();
    // assert head.item == null;
    Node<E> h = head; // 临时变量h
    Node<E> first = h.next;
    h.next = h; // 形成环引用help GC
    head = first;
    E x = first.item;
    first.item = null;
    return x;
}

4.1、poll()

// 队列为空返回null而不是抛异常
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 {
        if (count.get() > 0) {
            x = dequeue();
            c = count.getAndDecrement(); // 减1并返回旧值
            if (c > 1)
                notEmpty.signal(); // 唤醒其他取数据的线程
        }
    } finally {
        takeLock.unlock();
    }
 // c等于capacity说明poll之前队列已满，poll一个元素后便可唤醒其他等待插入数据的线程
    if (c == capacity)
        signalNotFull();
    return x;
}

衍生方法：

// 为poll方法增加了时间限制，指定时间未取回数据则返回null

public E poll(long timeout, TimeUnit unit)throws InterruptedException{}

4.2、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.await();
        }
        x = dequeue(); // 出队
        c = count.getAndDecrement();
        if (c > 1) // take数据前队列大小大于1，则take后队列至少还有1个元素
            notEmpty.signal(); // 唤醒其他取数据的线程
    } finally {
        takeLock.unlock();
    }
    if (c == capacity)
        signalNotFull(); //唤醒其他等待插入数据的线程
    return x;
}

4.3、drainTo(Collection<? super E> c, int maxElements)

// 移除最多maxElements个元素并将其加入集合

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;//p为临时变量，置null方便GC
                h.next = h;
                h = p;
                ++i;
            }
            return n;
        } finally {
            // Restore invariants even if c.add() threw
            if (i > 0) { // 有数据被转移到集合c中
                // assert h.item == null;
                head = h;
 //如果转移前的队列大小等于队列容量，则说明现在队列未满
 // 更新count为队列实际大小（减去i得到）
                signalNotFull = (count.getAndAdd(-i) == capacity);
            }
        }
    } finally {
        takeLock.unlock();
        if (signalNotFull)
            signalNotFull(); // 唤醒其他等待插入数据的线程
    }
}

衍生方法：

// 将[所有]可用元素加入集合c

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

4.4、boolean retainAll(Collection<?> c)

// 仅保留集合c中包含的元素，队列因此请求而改变则返回true

public boolean retainAll(Collection<?> c) {
    Objects.requireNonNull(c); // 集合为null则throw NPE
    boolean modified = false;
    Iterator<E> it = iterator();
    while (it.hasNext()) {
        if (!c.contains(it.next())) {
            it.remove();
            modified = true; // 队列因此请求而改变则返回true
        }
    }
    return modified;
}

LinkedBlockingQueue取数据小结：

线程A取数据前会获取takeLock锁，取完数据后释放锁。

队列有数据则（通常）返回队首数据；

若队列为空，则阻塞线程（notEmpty.await()）或返回null等；当线程B插入数据后，会调用notEmpty.signal()唤醒notEmpty上的等待线程（线程A继续取数据）。

若取数据前队列已满，则通过notFull.signal()唤醒notFull上等待插入数据的线程。

5、检测方法（取回但不移除）

5.1、E peek()

// 返回队列头，队列为空返回null

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、综述

6.1、LinkedBlockingQueue通过对 插入、取出数据 使用不同的锁，实现多线程对竞争资源的互斥访问；

6.2、（之前队列为空）添加数据后调用signalNotEmpty()方法唤醒等待取数据的线程；（之前队列已满）取数据后调用signalNotFull()唤醒等待插入数据的线程。这种唤醒模式可节省线程等待时间。

6.3、个别操作需要调用方法fullyLock()同时获取putLock、takeLock两把锁（如方法：clear()、contains(Object o)、remove(Object o)、toArray()、toArray(T[] a)、toString()），注意fullyLock和fullyUnlock获取锁和解锁的顺序刚好相反，避免死锁。

/**
 * Locks to prevent both puts and takes.
 */
void fullyLock() {
    putLock.lock();
    takeLock.lock();
}
/**
 * Unlocks to allow both puts and takes.
 */
void fullyUnlock() {
    takeLock.unlock();
    putLock.unlock();
}

6.4、线程唤醒signal()

值得注意的是，对notEmpty和notFull的唤醒操作均使用的是signal()而不是signalAll()。

signalAll() 虽然能唤醒Condition上所有等待的线程，但却并不见得会节省资源，相反，唤醒操作会带来上下文切换，且会有锁的竞争。此外，由于此处获取的锁均是同一个（putLock或takeLock），同一时刻被锁的线程只有一个，也就无从谈起唤醒多个线程了。

6.5、LinkedBlockingQueue与ArrayBlockingQueue简要比较

ArrayBlockingQueue底层基于数组，创建时必须指定队列大小，“有界”；LinkedBlockingQueue“无界”，节点动态创建，节点出队后可被GC，故伸缩性较好；

ArrayBlockingQueue入队和出队使用同一个lock（但数据读写操作已非常简洁），读取和写入操作无法并行，LinkedBlockingQueue使用双锁可并行读写，其吞吐量更高。

ArrayBlockingQueue在插入或删除元素时直接放入数组指定位置（putIndex、takeIndex），不会产生或销毁任何额外的对象实例；而LinkedBlockingQueue则会生成一个额外的Node对象，在高效并发处理大量数据时，对GC的影响存在一定的区别。

欢迎个人转载，但须在文章页面明显位置给出原文连接；
未经作者同意必须保留此段声明、不得随意修改原文、不得用于商业用途，否则保留追究法律责任的权利。

【 CSDN 】：csdn.zxiaofan.com
【GitHub】：github.zxiaofan.com

如有任何问题，欢迎留言。祝君好运！
Life is all about choices！ 
将来的你一定会感激现在拼命的自己！