LinkedBlockingQueue 源码学习

最新推荐文章于 2023-10-09 15:55:58 发布
最新推荐文章于 2023-10-09 15:55:58 发布
阅读量72 收藏
点赞数
分类专栏： Java 多线程 文章标签： 多线程 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013151053/article/details/117002753
版权

1. 概况

  • FIFO
  • 初始化时候指定了链表长度，默认为 Integer.MAX_VALUE，而节点是插入时才创建

2. 类定义

继承父类与实现接口与 ArrayBlockingQueue 一样。

public class LinkedBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable {
}

3. 成员变量

与 ArrayBlockingQueue 不一样的地方：

  • 使用两个 Lock 控制入队和出队；ArrayBlockingQueue 只有一个 LOCK 控制并发访问
  • 使用 AtomicInteger 记录当前链表的元素个数；ArrayBlockingQueue 则是使用一个基本类型的变量。
/** 容量大小，默认为 Integer.MAX_VALUE */
private final int capacity;

/** 链表中元素个数 */
private final AtomicInteger count = new AtomicInteger();
/**
 * 链表的头节点，这个头节点是空节点，即 head.item = null
 */
transient Node<E> head;
/**
 * 链表的尾节点，也是一个空节点，即 last.item = null
 */
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();

4. 构造方法

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) {
    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)); // 将元素放到链表尾部
            ++n;
        }
        count.set(n);
    } finally {
        putLock.unlock();
    }
}

// 相当于 last.next = node; last = last.next
private void enqueue(Node<E> node) {
    // assert putLock.isHeldByCurrentThread();
    // assert last.next == null;
    last = last.next = node;
}

5. 成员方法

5.1 入队方法

5.1.1 put

  • 使用 put 锁控制其它线程进行相关入队操作
  • 局部变量 c 用于唤醒正在等待的出队方法
public void put(E e) throws InterruptedException {
    if (e == null) throw new NullPointerException();
    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) {
            notFull.await();
        }
        // 入队操作
        enqueue(node);
       	// getAndIncrement 方法的返回是自增的元素，所以 c 被赋值添加元素之前的链表节点个数；并且 count++
        c = count.getAndIncrement();
        // 添加一个元素还没有满，通知等待队列，还可以进行入队操作
        if (c + 1 < capacity)
            notFull.signal();
    } finally {
        putLock.unlock();
    }
    // 若入队前队列size=0，此时队列元素个数为1，那么就唤醒正在等待出队的方法
    if (c == 0)
        signalNotEmpty(); 
}

5.1.2 offer

  • 与 put 方法类似，都是对 putLock 进行加锁控制
  • 带超时时间的 offer 方法增加了阻塞等待的功能
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 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) {
            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;
}

5.2 出队方法

5.2.1 poll

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();
    }
    if (c == capacity)  // 出队之前队列是满的，现在已经出队了，那么通知其它正在等待的 入队方法
        signalNotFull();
    return x;
}

// 仅在同步方法块中调用
private E dequeue() {
    // assert takeLock.isHeldByCurrentThread();
    // assert head.item == null;
    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;
}

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) {
            if (nanos <= 0)
                return null;
            nanos = notEmpty.awaitNanos(nanos);
        }
        x = dequeue();
        c = count.getAndDecrement();
        if (c > 1)
            notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
    if (c == capacity)
        signalNotFull();
    return x;
}

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

5.2.3 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)
            notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
    if (c == capacity)
        signalNotFull();  // 通知正在等待 入队的线程，可以放入元素了
    return x;
}

删除元素

从链表中删除指定元素，删除成功返回 true

public boolean remove(Object o) {
    if (o == null) return false;
    fullyLock();  // 两把锁都获取到再删除
    try {
        for (Node<E> trail = head, p = trail.next;
             p != null;
             trail = p, p = p.next) {
            if (o.equals(p.item)) {
                unlink(p, trail);
                return true;
            }
        }
        return false;
    } finally {
        fullyUnlock();
    }
}

// 将节点 P 从链表中移除，trail 是 p 节点的前一个节点
void unlink(Node<E> p, Node<E> trail) {
    // assert isFullyLocked();
    // p.next is not changed, to allow iterators that are
    // traversing p to maintain their weak-consistency guarantee.
    p.item = null;
    trail.next = p.next;
    if (last == p)
        last = trail; // 将 last 节点置为 p 的前置节点
    if (count.getAndDecrement() == capacity)
        notFull.signal();
}

6. 内部类

7. 思考

  1. LinkedBlockingQueue 为什么使用两个锁，而 ArrayBlockingQueue 只用一个锁？

首先，使用两个锁的吞吐量肯定比一个锁的大，因为入队和出队并不影响；ArrayBlockingQueue 之所以用一个锁，只能推测了，就是 数组实现出队，入队比较简单，再去用锁控制显得多余？

  1. 入队操作的时候，如果还没满，方法内容调用的是 notFull 条件队列，通知线程还可以添加；而 ArrayBlockingQueue 添加元素之后调用的是 notEmpty 条件队列，这里为何不一样？

因为 ArrayBlockingQueue 只有一个锁，如果添加元素之后再 notFull 通知正在等待的入队线程，消费线程可能很久以后才会拿到锁。

  1. 入队方法结尾，c 为什么不用加锁通知？ 为什么是 等于 0 或者 等于 captive 而不是 大于 0

c == 0 时，表明入队方法前队列为空，此时很有可能有消费线程在等待，所以得使用 signalNotEmpty 通知正在等待的消费线程

c > 0 时，队列是有数据的，此时消费线程可能都在消费中，此时通知的意义并不大。

菜鸟日常
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程 LinkedBlockingQueue源码分析
许诗宇的博客
05-06 247
目录 前言 成员 构造器 入队 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..
菜鸟看源码之LinkedBlockingQueue
leilifengxingmw的博客
03-15 486
首先扯点别的：已经不记得上次是什么时候做仰卧起坐的了，现在重新开始锻炼起来，腹肌还是得保持的。但是刚做了两天就感觉小腹酸疼。做20个都得咬牙坚持。明天继续做。 今天分析一下LinkedBlockingQueue的源码。LinkedBlockingQueue 是基于链表的阻塞队列，按照先进先出的顺序来排列元素。默认长度可以达到Integer.MAX_VALUE 。也可以指定LinkedBlocki...
手写LinkedBlockingQueue
qewgd的博客
03-09 338
原作者：老铁123　　　 出处：https://blog.csdn.net/qewgd/article/details/88363745　 本文归作者【老铁123】和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。 LinkedBlockingQueue基于链表的阻塞队列，生产者消费者模型应用。 import java.util....
BlockingQueue阻塞队列原理以及实现
zhenghuishengq的博客
07-10 1511
BlockingQueue原理及实现
BlockingQueue（阻塞队列）详解
javajy的博客
10-09 438
在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了BlockingQueue家庭中的所有成员，包括他们各自的功能以及常见使用场景。一旦获得了锁之后，如果队列为空，那么将阻塞；否则调用dequeue()出队一个元素。
生产者与消费者问题学习源码
11-10
Java并发库提供了一些内置的阻塞队列实现，如ArrayBlockingQueue和LinkedBlockingQueue。它们内置了线程安全和同步机制，可以方便地解决生产者与消费者问题。生产者通过put()方法添加元素到队列，消费者通过take()...
元素唯一的LinkedBlockingQueue阻塞队列
08-07
《元素唯一的LinkedBlockingQueue阻塞队列》 在Java并发编程中，`LinkedBlockingQueue`是一种基于...对于想要深入理解Java并发编程和数据结构的人来说，分析和实现`UniqueLinkedBlockingQueue`是一个很好的学习机会。
生产者/消费者模式 阻塞队列 LinkedBlockingQueue
06-08
生产者/消费者模式是软件设计模式中的一种经典模型，它...在阅读《xiongjiajia.iteye.com/blog/2325943》这篇博客文章时，你可以深入学习LinkedBlockingQueue的内部实现原理，以及如何在实际项目中有效利用这一工具。
java 线程池源码处理并发
05-10
通过阅读这些源码，我们可以学习到如何在Java中实现一个线程池，以及如何根据特定需求定制线程池的行为。 总之，Java线程池是并发编程中的重要工具，理解其源码有助于提升并发编程的效率和可控性。通过合理配置...
JAVA 多线程学习笔记
03-27
2. `BlockingQueue`：队列实现的线程通信，如`ArrayBlockingQueue`、`LinkedBlockingQueue`，适合生产者消费者模式。 五、线程池 1. `ExecutorService`：Java 5引入的线程池接口，通过`Executors`工厂类创建不同...
Java 并发工具包 java.util.concurrent 用户指南
热门推荐
Defonds 的专栏
03-03 18万+
1. java.util.concurrent - Java 并发工具包Java 5 添加了一个新的包到 Java 平台，java.util.concurrent 包。这个包包含有一系列能够让 Java 的并发编程变得更加简单轻松的类。在这个包被添加以前，你需要自己去动手实现自己的相关工具类。本文我将带你一一认识 java.util.concurrent 包里的这些类，然后你可以尝试着如何在项目中
Java Concurrent包源码学习和使用心得 之 LinkedBlockingQueue源码解读
A=X+Y+Z
06-11 2628
概述 LinkedBlockingQueue是java concurrent包提供的另一个多线程安全的阻塞队列，与ArrayBlockingQueu相比，此队列的使用链表实现（不熟悉链表的同学，请查阅大学的数据结构课本），可以提供高效的并发读写性能。 数据结构 链表节点 既然是链表，那么肯定少不了节点，节点自然包括节点内容和next指针。jdk开发人员，设计的节点是
基于LinkedBlockingQueue来实现生产者和消费者模型Demo
菜鸟不会飞
09-19 3429
      生产者消费者问题是多线程的一个经典问题，它描述是有一块缓冲区作为仓库，生产者可以将产品放入仓库，消费者则可以从仓库中取走产品。 解决生产者/消费者问题的方法可分为两类： 采用某种机制保护生产者和消费者之间的同步； 在生产者和消费者之间建立一个管道。 第一种方式有较高的效率，并且易于实现，代码的可控制性较好，属于常用的模式。第二种管道缓冲区不易控制，被传输数据对象不易于封装等，实用...
利用LinkedBlockingQueue实现生产者-消费者模式
nx7758520的博客
01-07 280
由于LinkedBlockingQueue 实现是线程安全的，实现了先进先出等特性，是作为生产者消费者的首选，LinkedBlockingQueue 可以指定容量，也可以不指定，不指定的话，默认最大是Integer.MAX_VALUE,其中主要用到put和take方法，put方法在队列满的时候会阻塞直到有队列成员被消费，take方法在队列空的时候会阻塞，直到有队列成员被放进来。下面是一个例...
使用LinkedBlockingQueue来实现生产者消费者的例子
hawanglc的博客
10-10 1321
工作中，经常有将文件中的数据导入数据库的表中，或者将数据库表中的记录保存到文件中。为了提高程序的处理速度，可以设置读线程和写线程，这些线程通过消息队列进行数据交互。本例就是使用了LinkedBlockingQueue来模仿生产者线程和消费者线程进行数据生产和消费。 为了方便，这些不同的类被写在了一个类中，实际使用的时候，可以单独拆开，举一反三地使用。 以下是例子： LinkedBlockingQ...
LinkedBlockingQueue与生产消费模型
我叫王菜鸟
06-05 680
生产消费模型 ReentrantLock提供了tryLock方法，tryLock调用的时候，如果锁被其他线程持有，那么tryLock会立即返回，返回结果为false；如果锁没有被其他线程持有，那么当前调用线程会持有锁，并且tryLock返回的结果为true。 对于ReentrantLock来说，还有一个十分实用的特性，它可以同时绑定多个Condition条件，以实现更精细化的同步控制。 R...
JAVA LinkedBlockingQueue详细分析
夜星
10-01 3104
java.util.concurrent.locks.AbstractQueuedSynchronizer是JUC(Java Util Concurrent)中非常重要的类. 其实现了同步锁的基本框架.
在线图书商城平台，资源由网络分享整理，如有侵权请联系我
07-23
网上书店系统是一个基于Web的应用程序，它允许用户在互联网上浏览、选购图书，并进行在线交易。这个系统通常由几个核心组件组成，包括前端用户界面、后台数据库管理、购物车功能、支付接口以及订单处理模块。下面我们将详细探讨这些知识点。 1. ASP.NET：ASP.NET是由微软开发的一个用于构建动态网站、应用程序和Web服务的框架。它支持多种编程语言，如C#，提供了丰富的功能和工具，简化了Web应用的开发过程。在本系统中，ASP.NET可能用于创建网页交互逻辑，处理用户请求并返回响应。 2. C#：C#是一种面向对象的编程语言，常用于构建Windows桌面应用和Web应用。在这个网上书店系统中，C#可能被用来编写服务器端的业务逻辑代码，处理用户输入，访问数据库，以及与各种服务进行交互。 3. 数据库：数据库是存储网上书店系统所有数据的地方，包括书籍信息（如书名、作者、出版社、价格等）、用户信息、订单详情等。常见的数据库管理系统如MySQL、SQL Server或Oracle可能被用于存储和检索这些数据。开发者需要使用SQL语句来设计和操作数据库，确保数据的一致性和完整性。 4. 系统
html+js制作的网页计算机 可以实现加减乘除等运算
最新发布
07-23
大二下半学期的网页设计课程作业 html+js制作的网页计算机 可以实现加减乘除等运算
请编写一个程序，基于LinkedList实现阻塞队列（可参考LinkedBlockingQueue源码）
04-10
好的，我会尽力回答您的问题。以下是基于LinkedList实现阻塞队列的示例代码： ```java import java.util.LinkedList; public class BlockingQueue<T> { private LinkedList<T> queue = new LinkedList();...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值