JDK源码分析-LinkedBlockingQueue

最新推荐文章于 2022-02-18 16:14:54 发布
最新推荐文章于 2022-02-18 16:14:54 发布
阅读量430 收藏 1
点赞数 3
分类专栏： JDK源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010551118/article/details/98342493
版权

概述

前文「JDK源码分析-ArrayBlockingQueue」分析了 ArrayBlockingQueue 的代码实现，LinkedBlockingQueue 也是阻塞队列的实现。与前者不同的是，后者内部是由链表实现的。

LinkedBlockingQueue 的继承结构如下：

640?wx_fmt=png

下面分析其主要方法的代码实现。

代码分析

LinkedBlockingQueue 内部有一个嵌套类 Node，它表示链表的节点，如下：

static class Node<E> {	
    E item; // 节点元素	

	
    Node<E> next; // 后继节点	
    	
    Node(E x) { item = x; }	
}

PS: 从 Node 定义可以看出该链表是一个单链表。

主要成员变量

// 链表的容量（若不指定则为 Integer.MAX_VALUE）	
private final int capacity;	

	
// 当前元素的数量（即链表中元素的数量）	
private final AtomicInteger count = new AtomicInteger();	

	
// 链表的头节点（节点元素为空）	
transient Node<E> head;	

	
// 链表的尾结点（节点元素为空）	
private transient Node<E> last;	

	
// take、poll 等出队操作持有的锁	
private final ReentrantLock takeLock = new ReentrantLock();	

	
/** Wait queue for waiting takes */	
// 出队锁的条件队列	
private final Condition notEmpty = takeLock.newCondition();	

	
// put、offer 等入队操作的锁	
private final ReentrantLock putLock = new ReentrantLock();	

	
/** Wait queue for waiting puts */	
// 入队锁的条件队列	
private final Condition notFull = putLock.newCondition();

构造器

LinkedBlockingQueue 有三个构造器，分别如下：

// 构造器 1：无参构造器，初始容量为 Integer.MAX_VALUE，即 2^31-1	
public LinkedBlockingQueue() {	
    this(Integer.MAX_VALUE);	
}	

	
// 构造器 2：指定容量的构造器	
public LinkedBlockingQueue(int capacity) {	
    if (capacity <= 0) throw new IllegalArgumentException();	
    this.capacity = capacity;	
    // 初始化链表的头尾节点	
    last = head = new Node<E>(null);	
}	

	
// 构造器 3：用给定集合初始化的构造器	
public LinkedBlockingQueue(Collection<? extends E> c) {	
    // 调用构造器 2 进行初始化	
    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");	
            // 将集合中的元素封装成 Node 对象，并添加到链表末尾	
            enqueue(new Node<E>(e));	
            ++n;	
        }	
        count.set(n);	
    } finally {	
        putLock.unlock();	
    }	
}

enqueue 方法如下：

// 将 node 节点添加到链表末尾	
private void enqueue(Node<E> node) {	
    last = last.next = node;	
}

主要入队方法：put(E)、offer(E, timeout, TimeUnit)、offer(E)

1. 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;	
    // 把 E 封装成 Node 节点	
    Node<E> node = new Node<E>(e);	
    final ReentrantLock putLock = this.putLock;	
    final AtomicInteger count = this.count;	
    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.	
         */	
        // 若队列已满，notFull 等待（类比生产者）	
        while (count.get() == capacity) {	
            notFull.await();	
        }	
        // node 入队	
        enqueue(node);	
        c = count.getAndIncrement();	
        // 若该元素添加后，队列仍未满，唤醒一个其他生产者线程	
        if (c + 1 < capacity)	
            notFull.signal();	
    } finally {	
        putLock.unlock();	
    }	
    // c==0 说明之前队列为空，出队线程处于等待状态，	
    // 添加一个元素后，将出队线程唤醒（消费者）	
    if (c == 0)	
        signalNotEmpty();	
}

signalNotEmpty 方法：

private void signalNotEmpty() {	
    final ReentrantLock takeLock = this.takeLock;	
    takeLock.lock();	
    try {	
        // 唤醒 notEmpty 条件下的一个线程（消费者）	
        notEmpty.signal();	
    } finally {	
        takeLock.unlock();	
    }	
}

2. offer(E, timeout, TimeUnit):

public boolean offer(E e, long timeout, TimeUnit unit)	
    throws InterruptedException {	
    if (e == null) throw new NullPointerException();	
    long nanos = unit.toNanos(timeout);	
    int c = -1;	
    final ReentrantLock putLock = this.putLock;	
    final AtomicInteger count = this.count;	
    putLock.lockInterruptibly();	
    try {	
        while (count.get() == capacity) {	
            // 等待超时，返回 false	
            if (nanos <= 0)	
                return false;	
            nanos = notFull.awaitNanos(nanos);	
        }	
        // 入队	
        enqueue(new Node<E>(e));	
        c = count.getAndIncrement();	
        if (c + 1 < capacity)	
            notFull.signal();	
    } finally {	
        putLock.unlock();	
    }	
    if (c == 0)	
        signalNotEmpty();	
    return true;	
}

该方法与 put 操作类似，不同的是 put 方法在队列满时会一直等待，而该方法有超时时间，超时后返回 false。

3. offer(E):

public boolean offer(E e) {	
    if (e == null) throw new NullPointerException();	
    final AtomicInteger count = this.count;	
    // 若队列已满，直接返回 false	
    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 下的线程，继续入队	
                notFull.signal();	
        }	
    } finally {	
        putLock.unlock();	
    }	
    if (c == 0)	
        signalNotEmpty();	
    return c >= 0;	
}

入队方法小结

1. put(E): 若队列已满，则等待，无返回值；

2. offer(E, timeout, TimeUnit): 与 put 方法类似，有超时等待和返回值；

3. offer(E): 立即返回，没有循环等待。

常用出队方法：take、poll(timeout, TimeUnit)、poll()、peek()

1. take():

public E take() throws InterruptedException {	
    E x;	
    int c = -1;	
    final AtomicInteger count = this.count;	
    final ReentrantLock takeLock = this.takeLock;	
    takeLock.lockInterruptibly();	
    try {	
        // 队列为空，notEmpty 条件下的线程等待（消费者）	
        while (count.get() == 0) {	
            notEmpty.await();	
        }	
        // 从队列头部删除节点	
        x = dequeue();	
        c = count.getAndDecrement();	
        // 若队列不为空，唤醒一个 notEmpty 条件下的线程（消费者）	
        if (c > 1)	
            notEmpty.signal();	
    } finally {	
        takeLock.unlock();	
    }	
    // 队列已经不满了，唤醒 notFull 条件下的线程（生产者）	
    if (c == capacity)	
        signalNotFull();	
    return x;	
}

dequeue 方法：

private E dequeue() {	
    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;	
}

signalNotFull: 

private void signalNotFull() {	
    final ReentrantLock putLock = this.putLock;	
    putLock.lock();	
    try {	
        // 唤醒生产者	
        notFull.signal();	
    } finally {	
        putLock.unlock();	
    }	
}

2. poll(timeout, TimeUnit):

public E poll(long timeout, TimeUnit unit) throws InterruptedException {	
    E x = null;	
    int c = -1;	
    long nanos = unit.toNanos(timeout);	
    final AtomicInteger count = this.count;	
    final ReentrantLock takeLock = this.takeLock;	
    takeLock.lockInterruptibly();	
    try {	
        // 队列已空	
        while (count.get() == 0) {	
            // 超时返回 null	
            if (nanos <= 0)	
                return null;	
            nanos = notEmpty.awaitNanos(nanos);	
        }	
        x = dequeue();	
        // 若队列不空，唤醒一个 notEmpty 条件下的线程（消费者）	
        c = count.getAndDecrement();	
        if (c > 1)	
            notEmpty.signal();	
    } finally {	
        takeLock.unlock();	
    }	
    // 队列不满，唤醒 notFull 条件下的线程（生产者）	
    if (c == capacity)	
        signalNotFull();	
    return x;	
}

与 take 方法类似，多了超时等待。

3. poll():

public E poll() {	
    final AtomicInteger count = this.count;	
    // 队列为空，返回 null	
    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();	
            // 该元素出队后，队列仍不为空，唤醒其他消费者	
            if (c > 1)	
                notEmpty.signal();	
        }	
    } finally {	
        takeLock.unlock();	
    }	
    // 队列已经不满，唤醒生产者	
    if (c == capacity)	
        signalNotFull();	
    return x;	
}

4. peek()

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

peek() 方法只返回头节点，并不删除。严格来说该方法并不属于出队操作，只是查询。

出队方法小结

1. take(): 获取队列头部元素，并将其移除，队列为空时阻塞等待；

2. poll(long, unit): 获取队列头部元素，并将其移除，队列为空时等待一段时间，若超时返回 null；

3. poll(): 获取队列头部元素，并将其移除，队列为空时返回 null；

小结

1. LinkedBlockingQueue 是基于单链表的阻塞队列实现，它在初始化时可以指定容量，若未指定，则默认容量为 Integer.MAX_VALUE；

2. 内部使用了 ReentrantLock 保证线程安全；

3. 常用方法：

    入队：put, offer

    出队：take, poll, peek

LinkedBlockingQueue 与 ArrayBlockingQueue 比较：

1. ArrayBlockingQueue 使用单个锁，可以指定是否公平；而 LinkedBlockingQueue 内部使用了两个锁：putLock 和 takeLock，都是非公平锁。

2. 入队出队区别

    入队时，LinkedBlockingQueue 会判断当前元素入队后，队列是否已满，若未满，则唤醒其他生产者线程；而入队后，当队列之前为空时才唤醒其他消费者线程。ArrayBlockingQueue 则是每次入队都会唤醒消费者线程。

    出队时，LinkedBlockingQueue 会判断当前元素出队后，队列是否已空，若未空，则唤醒其他消费者线程；而出队后，当队列之前为满时才唤醒其他生产者线程。ArrayBlockingQueue 则是每次出队都会唤醒生产者线程。

Stay hungry, stay foolish.

640?wx_fmt=png

WriteOnRead
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
并发队列之无界阻塞队列LinkedBlockingQueue
桐花思雨
05-26 1388
目录`LinkedBlockingQueue` 概述`LinkedBlockingQueue` 源码`LinkedBlockingQueue` 数据结构（单链表）`LinkedBlockingQueue` 主要属性 LinkedBlockingQueue 概述 LinkedBlockingQueue 来自于 jdk 1.5 的 JUC 包，是一个支持并发操作的有界阻塞队列，底层数据结构是一个单链表 作为有界队列，容量范围是{1, Integer.MAX_VALUE}，可以指定容量，如果未指定容量，则默认容
java多线程 LinkedBlockingQueue源码分析
许诗宇的博客
05-06 249
目录 前言 成员 构造器 入队 add offer put 超时offer 入队方法总结 出队 remove poll take 超时poll 出队方法总结 内部删除 remove(Object o) 获取操作 peek element 迭代器 总结 注意：本文转自 https://blog.csdn.net/anlian523/article/details/107601481 前言 LinkedBlockingQueue是一种FIFO（first-in..
jdk源码分析之 LinkedBlockingQueue
qq_42773076的博客
12-07 133
简介： 队列(queue)是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。LinkedBlockingQueue是基于链表实现的。 整体架构 LinkedBlockingQueue的类图如下： 从类图可以知道，LinkedBlockQueue实现的路线有两条。一、AbstarctQueue -> AbstarctCollection -&gt
jdk-LinkedBlockingQueue
lwgzj的博客
05-26 356
今天来看看啥的？昨天分析到Condition时最终写了个生产者消费者的例子，那么今天来看看生产者和消费者的其他实现方式吧。 除了最基本的wait和notify方式，这是基于Object的。我们昨天写了基于lock的await和signal方式，那么今天再看看LinkedBlockingQueue这个基于队列的实现方式。 下面是它的成员变量，都很简单，一个Node存储值，其他辅助性道具。不过Li
JDK8系列：阻塞队列 之 LinkedBlockingQueue（有界阻塞队列）源码解析
啦卡的博客
11-02 3291
1、LinkedBlockingQueue 简介 线程安全 底层实现原理：单项链表 + 2个ReentrantLock + 2个Condition 生产和消费数据用的不是同一独占锁，生产和消费是可以同时进行 生产者从队尾添加数据，消费者从队头的下一个节点开始获取数据 生产数据达到了容量则生产线程等待，消费者消费完了数据则消费者线程等待 头节点的数据项为null，不允许添加的数据项为null 2、成员变量 和 构造方法 public class LinkedBlockingQueue&lt..
java什么情况会挂_java – 为什么LinkedBlockingQueue#poll()可能会挂断？
weixin_28935433的博客
03-08 482
这是我的代码：// in constructorBlockingQueue queue = new LinkedBlockingQueue();// later in another threadNode node = queue.poll(1, TimeUnit.SECONDS);通常它可以工作，但有时候，在某些情况下(仍然不知道什么时候和为什么)poll()方法不返回NULL，但是将其线程永远...
JDK集合源码解析
weixin_43331475的博客
02-18 584
如何阅读JDK集合源码？ 一般需要关注以下地方： 继承体系 类继承、接口实现关系，可通过IDEA 编辑器Diagrams体现 数据结构 初始容量、扩容因子等 构造方法 对容器做了哪些初始化 常用方法解析（插入、删除、查询、迭代） 是否需要扩容？扩容机制？
bcprov-jdk15on-1.64运行包及源码.zip
04-20
标题中的"bcprov-jdk15on-1.64运行包及源码.zip"指的是Bouncy Castle Provider的Java版本1.64的运行时库和源代码压缩包。Bouncy Castle是一个开源的Java安全库，它提供了加密、数字签名、PKI（公钥基础设施）以及SSL...
bcpkix-jdk15on-1.62运行包及源码.zip
04-20
《深入理解bcpkix-jdk15on：加密安全框架与源码解析》 bcpkix-jdk15on是一个重要的加密安全框架，它为Java开发者提供了强大的证书和密钥管理功能，广泛应用于SSL/TLS协议、PKI（Public Key Infrastructure）系统...
bcpkix-jdk15on-1.59.jar
10-21
org/bouncycastle/jce/provider/BouncyCastleProvider bcpkix-jdk15on 需要 bcpkix-jdk15on-1.59 和 bcprov-jdk15on-1.59 才能匹配
javajdk源码解析-source-code-analysis:学习Java过程中的JDK源码分析
05-20
java jdk源码解析 source-code-analysis 学习Java过程中的记录
jdk-code-any:jdk源码分析
03-23
【文件名称列表】: jdk-code-any-master 这个文件名可能指的是一个包含JDK源码分析项目的Git仓库，"master"分支通常代表主分支，包含了项目的最新稳定版本。通过这样的仓库，开发者可以获取到源码、阅读注释、跟踪...
JDK6中LinkedBlockingQueue中的锁机制
jollyjumper的专栏
09-20 2231
常识，之前有的没搞清楚，导致写代码时不少疑惑。 比较典型的同步例子，用了两个Condition,notEmpty和notFull,分别对应两个lock,takeLock和putLock。查看take的代码: E x; int c = -1; final AtomicInteger count = this.count; final AtomicInteger takeLock = thi
JDK中LinkedBlockingQueue 内存泄漏问题
芝麻开花
06-01 4232
昨天晚上跑的程序，今早来的时候发现抛了个Java Heap: OutOfMemory的异常，于是觉得很奇怪。因为其实程序很简单，没有任何的输入而且线程都是Blocking住的，怎么会OutOfMemory呢？是开了JConsole看JVM的内存使用情况，过了一段时间，一条向上倾斜的直线很明显说明有内存泄露。为了确定泄露点，再开Profiling，发现Leak发生在LinkedBlockingQue...
jdk源码03-阻塞队列-LinkedBlockingQueue
文思源想的技术空间
10-11 223
1 阻塞队列定义 阻塞队列是一个在队列基础上又支持了两个附加操作的队列。 支持阻塞的插入：队列满时，队列会阻塞插入元素的线程，指导队列未满； 支持阻塞的移除：队列空时，获取元素的线程会阻塞，指导队列变为非空； 阻塞队列方法可以总结为如下所示： 方法处理方式 抛出异常 返回特殊值 一直阻塞 超时退出 插入方法 add(e) offer(e) put(e) offer(e,time,u...
JDK源码分析-ReentrantReadWriteLock
WriteOnRead
11-19 1887
概述 前面分析过 ReentrantLock「JDK源码分析-ReentrantLock」，它是一种互斥的可重入锁，可用于处理并发场景下的线程安全问题。而很多时候会出现“读多写少”的情况，若用 ReentrantLock 会降低并发量，此时就比较适合 ReentrantReadWriteLock 出场了。 ReentrantReadWriteLock 是读写锁，它维护了一对锁：一...
JDK源码分析-ScheduledExecutorService
WriteOnRead
09-25 404
概述接口的继承结构如下：下面分析这几个接口的定义。Executor从名字来看，Executor 可译为“执行器”，它的作用就是执行任务。该接口只有一个 execute 方...
JDK源码分析-ArrayBlockingQueue
WriteOnRead
07-24 385
概述前文「JDK源码分析-BlockingQueue」简要分析了 BlockingQueue 接口的主要方法，ArrayBlockingQueue 就是该接口的一个主要实...
jdk-11-windows
最新发布
10-28
jdk-11-windows是指Java开发工具包（Java Development Kit）的第11个版本，适用于Windows操作系统。JDK是使用Java语言进行开发的应用程序和软件的环境，它提供了许多工具和功能，可用于编写、编译和运行Java程序。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值