26.jdk源码阅读之ConcurrentLinkedQueue

最新推荐文章于 2024-09-06 18:50:44 发布
最新推荐文章于 2024-09-06 18:50: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
    评论
专栏目录
JDK_seaswalker.tar.gz
10-20
JDK源码阅读笔记 Condition CountDownLatch CyclicBarrier ReadWriteLock ReentrantLock Socket UDP IO FileChannel Buffer URLConnection NIO Process HashMap LinkedHashMap TreeMap ...
JDK8源码阅读（十七） ConcurrentLinkedQueue TODO
请叫我猿叔叔的博客
06-25 195
一、简介 二、分析 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...
JAVA后端架构师.pdf
04-10
7. 并发集合基础知识：ConcurrentHashMap实战与原理、源码详解、ConcurrentLinkedQueue实战与原理、源码详解、ConcurrentSkipListMap实战与原理、源码详解、CopyOnWriteArrayList实战与原理、源码详解等。...
JavaCommon:Java基础用法，集合，线程，JUC，jdk5--8各个版本特性。
03-23
该项目还深入解析了从JDK 5到JDK 8各版本的重要特性，为开发者提供了丰富的代码示例和源码分析。 1. **Java基础用法**： - **变量与数据类型**：Java支持基本数据类型如int、float、char等，以及引用类型如类、...
JavaStudy:Java原始语言学习：JDK，Spring，Mybatis等
03-23
源码刻意学习小组[目录]一，学习周期（2个月）时间内容主要类第一周（2019/12 / 09-2019 / 12.15）简单集合ArrayList，HashMap，LinkedList第二周（2019/12 / 16-2019 / 12.22）原子类不安全，AtomicInteger，...
汪文君高并发编程实战视频资源下载.txt
08-08
│ 源码+ppt.rar │ 高并发编程第一阶段01讲、课程大纲及主要内容介绍.wmv │ 高并发编程第一阶段02讲、简单介绍什么是线程.wmv │ 高并发编程第一阶段03讲、创建并启动线程.mp4 │ 高并发编程第一阶段04讲、...
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1274
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
okhttp，retrofit,rxjava 是如何配合工作的 作用分别是什么
追梦的鱼儿
09-04 503
OkHttp、Retrofit 和 RxJava 是 Android 开发中常用的三种库，它们各自有不同的作用，并且可以很好地配合工作来实现网络请求和响应的处理。
SpringBoot 项目集成 xxl-job
qq_58159506的博客
09-03 655
SpringBoot 项目集成 xxl-job
nmt---Docker-compose自动化部署
qq_69920145的博客
09-03 1021
static-rr 权重, leastconn 最少连接, source 请求IP, 轮询 roundrobin。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。10. docker-compose移除容器。
在Java Web开发中，如何保障应用的安全性？请列举常见的安全策略和措施。请解释Spring框架中的事务管理，包括声明式事务和编程式事务。
weixin_53180424的博客
09-03 963
在实际开发中，声明式事务管理因其非侵入性和易维护性而更受欢迎。它允许开发者将注意力集中在业务逻辑上，而不是事务管理的细节上。然而，在某些特殊场景下，编程式事务管理可能提供更灵活的控制力。因此，在选择事务管理方式时，应根据实际需求和场景来决定。
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 822
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
数据访问：JPA
hhgh_的博客
09-02 1020
其二，Sun希望整合ORM 技术，实现统一的 API调用接口。@Table（name=“”,catalog=“”,schema=“”）可选，用来标注一个数据库对应的实体类，数据库中创建的表明默认和类名一致，通常和@Entity配合使用，只能标注在实体的class定义处，表示实体对应的数据库表的信息。@Entity(name=“EntityName”)必须，用来标注一个数据库表对应的实体，数据库中创建的表明默认和类名一致，其中，name可选，对应数据库中的一个表，使用此注解标记Pojo是一个JPA实体。
MapStruct-Java实体转换利器
m0_63622279的博客
09-02 521
MapStruct 是一个用于生成映射器接口的代码生成库，主要用于简化 Java 对象之间的转换过程。在处理不同模型之间数据转换时，MapStruct 可以自动生成实现类减少手工转换逻辑的工作量。使用场景：各种模型之间的转换。BODTOVOPOJO引入mapstruct的pom依赖定义mapper接口（注意，这里不是MyBatis的Mapper哦），使用@Mapper注解标记，并在接口中声明映射方法。编写映射方法，（从xxxO转换为yyyO,模型之间的转换）在业务层中使用Mapper。
JavaWeb（基于SpringBoot开发）全总结（1）
2302_81420820的博客
09-02 999
再到spring boot中去设置，当我们遇到报错不要紧，我们直接再复制我们在DG上面写的sql语句，到idea那个数据库那里再运行一次，2.由于使用不同开发工具开发出来的略有不同，导致不能够互通，所以国际规定，使用maven创建的项目为统一标准结构，也就是下图所示的结构。还有我们写的案例里面的mapper层写的sql语句的新增，删除，等等操作，都是基于mybatis来实现的。例如：传入的是路径参数，json格式的参数等等，根据不同的参数我们使用不同的注解。
java后端开发-Mybatis连接数据库步骤
weixin_73355603的博客
09-02 1923
🎙座右铭：得之坦然，失之淡然。💎擅长领域：前端是的，我需要您的：是我持续下去的动力！先看看目录，是不是IDEA的配置，数据库mysql或者其他的数据库这套方法都适合的。
SpringBoot总结
2302_77073236的博客
09-06 90
都做成图了，方便理解和掌握全局关系。
基于SpringBoot的多媒体信息共享平台开发
最新发布
qq_45800365的博客
09-06 141
基于SpringBoot的多媒体信息共享平台开发,java项目。eclipse和idea都能打开运行。推荐环境配置：eclipse/idea jdk1.8 maven mysql前端技术：vue，Ajax，Json后端技术：SpringBoot，MyBatis本系统共分为两个角色：管理员和用户。主要功能有:后台：系统首页个人中心用户管理作品分类管理作品信息管理私聊信息管理系统管理前台：首页作品信息公告信息后台管理个人中心。
【计算机毕业设计】高校课堂教学管理系统
weixin_47772925的博客
09-04 1113
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、付费专栏及课程。

余额充值