26.jdk源码阅读之ConcurrentLinkedQueue

最新推荐文章于 2024-09-04 16:58:44 发布
最新推荐文章于 2024-09-04 16:58:44 发布
阅读量1k 收藏 16
点赞数 25
分类专栏： JDK源码 文章标签： java 开发语言
本文为 至真源 原创，转载请注明出处，谢谢！
本文链接：https://blog.csdn.net/yunkongbian2616/article/details/140766298
版权

1. 写在前面

在这里插入图片描述
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。不知道大家在日常工作中这个类用的多不多，它的一些实现细节原理是否有思考过，比如下面这个几个问题：

  1. ConcurrentLinkedQueue 和 LinkedBlockingQueue 有什么区别？
  2. ConcurrentLinkedQueue 使用了哪些关键技术来实现线程安全？
  3. 如何确保 ConcurrentLinkedQueue 的高并发性能？
  4. ConcurrentLinkedQueue 的典型使用场景有哪些？
  5. ConcurrentLinkedQueue 如何实现无锁的插入和删除操作？
  6. ConcurrentLinkedQueue 的弱一致性是什么？
  7. ConcurrentLinkedQueue 的 size 方法是线程安全的吗？
  8. ConcurrentLinkedQueue 的迭代器是线程安全的吗？

2. 从使用说起

2.1 任务调度

在多线程环境中，使用 ConcurrentLinkedQueue 存储待处理的任务，并由多个工作线程并发地处理这些任务。

import java.util.concurrent.ConcurrentLinkedQueue;

public class TaskScheduler {
    private ConcurrentLinkedQueue<Runnable> taskQueue = new ConcurrentLinkedQueue<>();
    private volatile boolean running = true;

    // 添加任务到队列
    public void addTask(Runnable task) {
        taskQueue.offer(task);
    }

    // 启动工作线程
    public void startWorkers(int numWorkers) {
        for (int i = 0; i < numWorkers; i++) {
            new Thread(() -> {
                while (running) {
                    Runnable task = taskQueue.poll();
                    if (task != null) {
                        task.run();
                    }
                }
            }).start();
        }
    }

    // 停止任务调度
    public void stop() {
        running = false;
    }

    public static void main(String[] args) {
        TaskScheduler scheduler = new TaskScheduler();

        // 添加任务
        scheduler.addTask(() -> System.out.println("Task 1 executed"));
        scheduler.addTask(() -> System.out.println("Task 2 executed"));

        // 启动工作线程
        scheduler.startWorkers(2);

        // 为了演示方便，延迟 5 秒后停止任务调度
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        scheduler.stop();
    }
}

2.2 事件驱动系统

在事件驱动系统中，使用 ConcurrentLinkedQueue 存储和处理事件。

import java.util.concurrent.ConcurrentLinkedQueue;

public class EventDrivenSystem {
    private ConcurrentLinkedQueue<String> eventQueue = new ConcurrentLinkedQueue<>();
    private volatile boolean running = true;

    // 添加事件到队列
    public void addEvent(String event) {
        eventQueue.offer(event);
    }

    // 处理事件
    public void startEventProcessor() {
        new Thread(() -> {
            while (running) {
                String event = eventQueue.poll();
                if (event != null) {
                    processEvent(event);
                }
            }
        }).start();
    }

    // 处理事件的逻辑
    private void processEvent(String event) {
        System.out.println("Processing event: " + event);
    }

    // 停止事件处理
    public void stop() {
        running = false;
    }

    public static void main(String[] args) {
        EventDrivenSystem system = new EventDrivenSystem();

        // 添加事件
        system.addEvent("Event 1");
        system.addEvent("Event 2");

        // 启动事件处理
        system.startEventProcessor();

        // 为了演示方便，延迟 5 秒后停止事件处理
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        system.stop();
    }
}

2.3 消息队列

分布式系统中，使用 ConcurrentLinkedQueue 实现简单的消息队列。

import java.util.concurrent.ConcurrentLinkedQueue;

public class MessageQueue {
    private ConcurrentLinkedQueue<String> messageQueue = new ConcurrentLinkedQueue<>();
    private volatile boolean running = true;

    // 生产者线程：添加消息到队列
    public void startProducer() {
        new Thread(() -> {
            int messageCount = 0;
            while (running) {
                String message = "Message " + messageCount++;
                messageQueue.offer(message);
                System.out.println("Produced: " + message);
                try {
                    Thread.sleep(1000); // 模拟生产间隔
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

    // 消费者线程：从队列中取出消息并处理
    public void startConsumer() {
        new Thread(() -> {
            while (running) {
                String message = messageQueue.poll();
                if (message != null) {
                    System.out.println("Consumed: " + message);
                }
            }
        }).start();
    }

    // 停止消息队列
    public void stop() {
        running = false;
    }

    public static void main(String[] args) {
        MessageQueue queue = new MessageQueue();

        // 启动生产者和消费者线程
        queue.startProducer();
        queue.startConsumer();

        // 为了演示方便，延迟 10 秒后停止消息队列
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        queue.stop();
    }
}

2.4 生产者-消费者模式

使用 ConcurrentLinkedQueue 实现生产者-消费者模式。

import java.util.concurrent.ConcurrentLinkedQueue;

public class ProducerConsumer {
    private ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();
    private volatile boolean running = true;

    // 生产者线程：生成数据并添加到队列
    public void startProducer() {
        new Thread(() -> {
            int count = 0;
            while (running) {
                queue.offer(count++);
                System.out.println("Produced: " + count);
                try {
                    Thread.sleep(500); // 模拟生产间隔
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

    // 消费者线程：从队列中取出数据并处理
    public void startConsumer() {
        new Thread(() -> {
            while (running) {
                Integer data = queue.poll();
                if (data != null) {
                    System.out.println("Consumed: " + data);
                }
            }
        }).start();
    }

    // 停止生产和消费
    public void stop() {
        running = false;
    }

    public static void main(String[] args) {
        ProducerConsumer pc = new ProducerConsumer();

        // 启动生产者和消费者线程
        pc.startProducer();
        pc.startConsumer();

        // 为了演示方便，延迟 10 秒后停止生产和消费
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        pc.stop();
    }
}

3. add(E e)底层实现

  public boolean add(E e) {
        return offer(e);
    }
 public boolean offer(E e) {
        checkNotNull(e);
        final Node<E> newNode = new Node<E>(e);

        for (Node<E> t = tail, p = t;;) {
            Node<E> q = p.next;
            if (q == null) {
                // p is last node
                if (p.casNext(null, newNode)) {
                    // Successful CAS is the linearization point
                    // for e to become an element of this queue,
                    // and for newNode to become "live".
                    if (p != t) // hop two nodes at a time
                        casTail(t, newNode);  // Failure is OK.
                    return true;
                }
                // Lost CAS race to another thread; re-read next
            }
            else if (p == q)
                // We have fallen off list.  If tail is unchanged, it
                // will also be off-list, in which case we need to
                // jump to head, from which all live nodes are always
                // reachable.  Else the new tail is a better bet.
                p = (t != (t = tail)) ? t : head;
            else
                // Check for tail updates after two hops.
                p = (p != t && t != (t = tail)) ? t : q;
        }
    }

3.1 add 方法

add 方法只是简单地调用 offer 方法。add 方法在 Collection 接口中定义，而 offer 方法在 Queue 接口中定义。两者在 ConcurrentLinkedQueue 中的实现是相同的。

3.2 offer 方法

  1. checkNotNull(e)
    这个方法检查传入的元素是否为 null，如果是 null，则抛出 NullPointerException。ConcurrentLinkedQueue 不允许存储 null 元素。
  2. 创建新节点
final Node<E> newNode = new Node<E>(e);

创建一个新的节点来存储传入的元素。

  1. 循环遍历队列
for (Node<E> t = tail, p = t;;) {
    Node<E> q = p.next;

初始化两个节点引用 t 和 p，都指向队列的尾节点 tail。然后进入无限循环，遍历队列。
4. 检查 p.next

if (q == null) {
    // p is last node
    if (p.casNext(null, newNode)) {
        // Successful CAS is the linearization point
        // for e to become an element of this queue,
        // and for newNode to become "live".
        if (p != t) // hop two nodes at a time
            casTail(t, newNode);  // Failure is OK.
        return true;
    }
    // Lost CAS race to another thread; re-read next
}

如果 q 为 null，说明 p 是当前的尾节点。尝试通过 CAS 操作将 newNode 插入到 p.next。

  • 如果 CAS 操作成功，newNode 成为了队列的新尾节点。
  • 如果 p 不等于 t，说明 tail 已经更新，需要更新 tail 指向 newNode。
  • 返回 true，表示插入成功。
    如果 CAS 操作失败，说明有其他线程已经插入了新节点，需要重新读取 p.next。
  1. 处理尾节点不一致的情况
else if (p == q)
    // We have fallen off list.  If tail is unchanged, it
    // will also be off-list, in which case we need to
    // jump to head, from which all live nodes are always
    // reachable.  Else the new tail is a better bet.
    p = (t != (t = tail)) ? t : head;

如果 p 等于 q，说明我们已经遍历到了队列的末尾。此时需要重新检查 tail，如果 tail 没有变化，则跳转到 head 节点重新开始遍历。
6. 正常遍历队列

else
    // Check for tail updates after two hops.
    p = (p != t && t != (t = tail)) ? t : q;

如果 p.next 不为 null，说明当前节点不是尾节点。继续遍历队列，并在必要时更新 tail。

4. poll()的底层实现

下面这段代码是 ConcurrentLinkedQueue 中的 poll() 方法的实现。poll 方法用于从队列的头部移除并返回一个元素，如果队列为空则返回 null。

    public E poll() {
        restartFromHead:
        for (;;) {
            for (Node<E> h = head, p = h, q;;) {
                E item = p.item;

                if (item != null && p.casItem(item, null)) {
                    // Successful CAS is the linearization point
                    // for item to be removed from this queue.
                    if (p != h) // hop two nodes at a time
                        updateHead(h, ((q = p.next) != null) ? q : p);
                    return item;
                }
                else if ((q = p.next) == null) {
                    updateHead(h, p);
                    return null;
                }
                else if (p == q)
                    continue restartFromHead;
                else
                    p = q;
            }
        }
    }

4.1 无限循环和标签

restartFromHead:
for (;;) {
    for (Node<E> h = head, p = h, q;;) {

使用无限循环 for (;😉 来不断尝试移除元素。restartFromHead 是一个标签，用于在某些情况下重新从队列的头部开始遍历。

初始化两个节点引用 h 和 p，都指向队列的头节点 head。

4.2 获取当前节点的元素

E item = p.item;

获取当前节点 p 的元素 item。

4.3 尝试通过 CAS 操作移除元素

if (item != null && p.casItem(item, null)) {
    // Successful CAS is the linearization point
    // for item to be removed from this queue.
    if (p != h) // hop two nodes at a time
        updateHead(h, ((q = p.next) != null) ? q : p);
    return item;
}

如果 item 不为 null，说明当前节点 p 存储了一个有效的元素。尝试通过 CAS 操作将 p.item 设置为 null，表示移除该元素。

  • 如果 CAS 操作成功，说明元素已经成功移除。
  • 如果 p 不等于 h，说明 head 已经更新。调用 updateHead 方法更新 head 指向新的头节点 q 或者 p。
  • 返回移除的元素 item。

4.4 处理队列为空的情况

else if ((q = p.next) == null) {
    updateHead(h, p);
    return null;
}

如果 p.next 为 null，说明当前节点 p 是队列的尾节点，队列为空。调用 updateHead 方法更新 head 指向 p，然后返回 null。

4.5 处理尾节点不一致的情况

else if (p == q)
    continue restartFromHead;

如果 p 等于 q，说明我们已经遍历到了队列的末尾。此时需要重新从队列的头部开始遍历，使用 continue restartFromHead 标签跳转到外层循环的开始。

4.6 正常遍历队列

else
    p = q;

如果 p.next 不为 null，说明当前节点不是尾节点。继续遍历队列，将 p 更新为 p.next。

系列文章

1.JDK源码阅读之环境搭建

2.JDK源码阅读之目录介绍

3.jdk源码阅读之ArrayList(上)

4.jdk源码阅读之ArrayList(下)

5.jdk源码阅读之HashMap

6.jdk源码阅读之HashMap（下）

7.jdk源码阅读之ConcurrentHashMap(上)

8.jdk源码阅读之ConcurrentHashMap（下）

9.jdk源码阅读之ThreadLocal

10.jdk源码阅读之ReentrantLock

11.jdk源码阅读之CountDownLatch

12.jdk源码阅读之CyclicBarrier

13.jdk源码阅读之Semaphore

14.jdk源码阅读之线程池(上)

15.jdk源码阅读之线程池(下)

16.jdk源码阅读之ArrayBlockingQueue

17.jdk源码阅读之LinkedBlockingQueue

18.jdk源码阅读之CopyOnWriteArrayList

19.jdk源码阅读之FutureTask

20.jdk源码阅读之CompletableFuture

21.jdk源码阅读之AtomicLong

22.jdk源码阅读之Thread(上)

23.jdk源码阅读之Thread(下)

24.jdk源码阅读之ExecutorService

25.jdk源码阅读之Executors

至真源
关注
  • 25
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
第十四篇：ConcurrentLinkedQueue的源码解析（基于JDK1.8）
码农飞哥
02-14 1928
ConcurrentLinkedQueue的定义 ConcurrentLinkedQueue是 非阻塞的单端队列，其是一个通过链表实现的并发安全的队列。是java中并发环境下性能最好的队列，它是使用非阻塞算法（CAS）来实现线程安全的。它采用先进先出的规则对节点进行排序，当我们添加一个元素时，它会添加到队列的尾部;当我们获取一个元素时，它会返回队列头部的元素。 ConcurrentLinkerQu...
JDK8源码阅读（十七） ConcurrentLinkedQueue TODO
请叫我猿叔叔的博客
06-25 193
一、简介 二、分析 2.1 类结构 2.1.0 类结构图 2.2 内部类 2.2.0 内部类列表图 2.2.1Itr 2.2.2Node 2.3 字段 2.3.0 字段列表图 2.3.1array /** * 内部维护的数组集合，只能通过getArray或setArray来访问 */ private transi...
27.jdk源码阅读之ConcurrentLinkedDeque
前端、移动端、后端源码级底层原理分享
07-30 573
ConcurrentLinkedDeque 是 Java 中一个高效、线程安全的双端队列（Deque），使用无锁算法（CAS 操作）来保证线程安全性。由于其复杂的实现和广泛的应用场景，它常常成为面试中的重点考察对象。不知道下面几个问题你在面试过程中有没有被问到过？
ConcurrentLinkedQueue 源码浅析
weixin_54568599的博客
06-07 400
队列是一种常见的数据结构，主要特点是 FIFO，Java 为其定义了接口类：Queue，并提供了丰富的实现，有底层基于数组的[有界]队列，也有基于节点链接的无界队列，有阻塞队列，有非阻塞队列，还有并发安全的队列。 常见的队列实现的两种方式：数组、节点链接。 Java 对队列的基本实现在包：java.util 中，对并发安全实现主要存在于 Java 的 JUC 包下。 在使用 Java 的线程池工具：ThreadPoolExecutor，其使用阻塞队列来缓存任务，因为阻塞队列具备通知唤醒的功能，能够在任务
ConcurrentLinkedQueue源码分析
茫然背影的博客
05-14 541
并编程中，一般需要用到安全的队列，如果要自己实现安全队列，可以使用2种方式： 方式1：加锁，这种实现方式就是我们常说的阻塞队列。 方式2：使用循环CAS算法实现，这种方式实现队列称之为非阻塞队列。 从点到面， 下面我们来看下非阻塞队列经典实现类：ConcurrentLinkedQueue （JDK1.8版） ConcurrentLinkedQueue 是一个基于链接节点的无界线程安全的队列，按照先进先出原则对元素进行排序。新元素从队列尾部插入，而获取队列元素，则需要从队列头部获取 ...
JDK源码那些事儿之LockSupport
Orange's Life
05-10 159
前面一篇文章中说明了Object的阻塞唤醒机制，今天我们要讲解另一个类LockSupport，在AQS中你能看见它的身影，所以需要提前了解其实现和使用机制，便于后面深入AQS的学习
Queue常用类解析之ConcurrentLinkedQueue
翻身已碰头的博客
04-21 494
Queue常用类解析之PriorityQueue
JDK_seaswalker.tar.gz
10-20
JDK源码阅读笔记 Condition CountDownLatch CyclicBarrier ReadWriteLock ReentrantLock Socket UDP IO FileChannel Buffer URLConnection NIO Process HashMap LinkedHashMap TreeMap ...
【JavaWeb】JDBC&Druid&Tomcat入门使用
lklalmq的博客
09-04 803
预编译SQL语句并执行：预防SQL注入问题获取 PreparedStatement 对象// SQL语句中的参数值，使用？占位符替代?// 通过Connection对象获取，并传入对应的sql语句设置参数值上面的sql语句中参数使用?进行占位，在之前之前肯定要设置 这些?的值。PreparedStatement对象：setXxx(参数1，参数2)：给?赋 值Xxx：数据类型；如 setInt (参数1，参数2)参数：参数1：？的位置编号，从1 开始参数2：？的值执行SQL语句。
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 3208
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
okhttp，retrofit,rxjava 是如何配合工作的 作用分别是什么
追梦的鱼儿
09-04 178
OkHttp、Retrofit 和 RxJava 是 Android 开发中常用的三种库，它们各自有不同的作用，并且可以很好地配合工作来实现网络请求和响应的处理。
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1193
浅析synchronized锁升级的原理与实现
JVM 垃圾回收机制：GC
m0_60462557的博客
09-04 765
JVM的垃圾回收机制：GC，是Java提供的对于内存自动回收的机制。
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 670
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
JavaWeb（基于SpringBoot开发）全总结（1）
2302_81420820的博客
09-02 847
再到spring boot中去设置，当我们遇到报错不要紧，我们直接再复制我们在DG上面写的sql语句，到idea那个数据库那里再运行一次，2.由于使用不同开发工具开发出来的略有不同，导致不能够互通，所以国际规定，使用maven创建的项目为统一标准结构，也就是下图所示的结构。还有我们写的案例里面的mapper层写的sql语句的新增，删除，等等操作，都是基于mybatis来实现的。例如：传入的是路径参数，json格式的参数等等，根据不同的参数我们使用不同的注解。
输入三个正整数，找出不大不小的值
laocooon的博客
08-30 1686
/ 找出最大值，找出最小值，然后不是最大值也不是最小值的。// 2、输入三个正整数，找出不大不小的值。
安装Android Studio及第一个Android工程可能遇到的问题
学无止境，止于至善
09-04 315
Android Studio版本众多，电脑操作系统、电脑型号、电脑硬件也是多种多样，幸运的半个小时内可以完成安装，碰到不兼容的电脑，一天甚至更长时间都无法安装成功。Android安装及第一个Android工程分为4个步骤，为什么放到一起讲，因为只有Android的第一个工程运行到虚拟机上，Android的开发环境搭建才算完成。
【计算机毕业设计】高校课堂教学管理系统
最新发布
weixin_47772925的博客
09-04 289
2.1Java是由SUN公司推出，该公司于2010年被oracle公司收购。Java本是印度尼西亚的一个叫做爪洼岛的英文名称，也因此得来java是一杯正冒着热气咖啡的标识。Java语言在移动互联网的大背景下具备了显著的优势和广阔的前景，它是面向对象的，分布式的，动态的，具有平台无关性、安全性、健壮性。Java语言的基本语句语法和C++一样，但是它面向对象的技术更加彻底，因为Java要求将所有的内容都必须封装成类，把类作为程序的基本单位。由于不允许类外有变量、方法。
手把手教你搭建Spring 5.3.x源码阅读环境
"搭建spring5.3.x源码阅读环境，主要涉及spring框架，使用intellij idea作为IDE，通过gradle构建系统进行源码编译和测试。" 在深入研究Spring框架的设计与实现时，理解其源码至关重要。本文提供了一个详尽的指南，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

至真源

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值