LinkedBlockingQueue源码分析(JDK8)

版权声明:【分享也是一种提高】个人转载请在正文开头明显位置注明出处,未经作者同意禁止企业/组织转载,禁止私自更改原文,禁止用于商业目的。 https://blog.csdn.net/u010887744/article/details/73010691
本文分析LinkedBlockingQueue的源码,学习其底层实现。
你可以通过我的这篇文章《阻塞队列BlockingQueue(JDK8)》了解阻塞队列的基本使用及各个方法的对比分析。
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! 
将来的你一定会感激现在拼命的自己!

没有更多推荐了,返回首页