JDK源码——线程安全的双端队列

于 2024-08-14 07:15:00 发布
阅读量680 收藏 16
点赞数 30
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Luck_gun/article/details/141176422
版权

LinkedBlockingDeque<E> 和 ConcurrentLinkedDeque<E> 都是 Java 集合框架中的双端队列实现。它们都允许在两端插入和移除元素，并且是线程安全的。
在这里插入图片描述

LinkedBlockingDeque

LinkedBlockingDeque<E> 是一个基于链表的阻塞双端队列，它实现了 BlockingDeque 接口。当尝试从空队列中取出元素或向满队列中添加元素时，如果有必要，它会阻塞当前线程直到操作成功。

方法如下：
在这里插入图片描述

  • pollLast(): 从队列的尾部移除并返回元素，如果队列为空则返回null。
  • removeFirstOccurrence(Object): 从队列中移除第一次出现的指定元素（如果存在），成功时返回true，否则返回false。
  • putLast(E): 将指定的元素添加到队列的尾部。
  • remainingCapacity(): 返回队列剩余的容量。
  • drainTo(Collection<E>, int): 移除队列中的最多指定数量的元素并将它们添加到给定的集合中，返回实际移除的元素数量。
  • element(): 返回队列头部的元素但不移除它，如果队列为空则抛出异常。
  • peekFirst(): 返回队列头部的元素但不移除它，如果队列为空则返回null。
  • removeLastOccurrence(Object): 从队列中移除最后一次出现的指定元素（如果存在），成功时返回true，否则返回false。
  • drainTo(Collection<E>): 移除队列中的所有元素并将它们添加到给定的集合中，返回实际移除的元素数量。
  • put(E): 将指定的元素添加到队列的尾部。
  • remove(Object): 从队列中移除指定的元素（如果存在），成功时返回true，否则返回false。
  • pollLast(long, TimeUnit): 在指定的时间内从队列的尾部移除并返回元素，如果在指定时间内没有元素可用则返回null。
  • takeFirst(): 移除并返回队列头部的元素，如果队列为空则阻塞等待直到有元素可用。
  • peek(): 返回队列头部的元素但不移除它，如果队列为空则返回null。
  • remove(): 移除并返回队列头部的元素，如果队列为空则抛出异常。
  • contains(Object): 检查队列是否包含指定的元素。
  • offer(E, long, TimeUnit): 将指定的元素添加到队列的尾部，在指定的时间内等待空间可用，成功时返回true，否则返回false。
  • toString(): 返回队列的字符串表示形式。
  • offerLast(E, long, TimeUnit): 将指定的元素添加到队列的尾部，在指定的时间内等待空间可用，成功时返回true，否则返回false。
  • take(): 移除并返回队列头部的元素，如果队列为空则阻塞等待直到有元素可用。
  • pollFirst(long, TimeUnit): 在指定的时间内从队列的头部移除并返回元素，如果在指定时间内没有元素可用则返回null。
  • size(): 返回队列中的元素数量。
  • push(E): 将指定的元素添加到队列的头部。
  • add(E): 将指定的元素添加到队列的尾部，成功时返回true，否则抛出异常。
  • pollFirst(): 从队列的头部移除并返回元素，如果队列为空则返回null。
  • poll(): 从队列的头部移除并返回元素，如果队列为空则返回null。
  • takeLast(): 移除并返回队列尾部的元素，如果队列为空则阻塞等待直到有元素可用。
  • iterator(): 返回一个迭代器，用于遍历队列中的元素。
  • offerFirst(E): 将指定的元素添加到队列的头部，成功时返回true，否则抛出异常。
  • offer(E): 将指定的元素添加到队列的尾部，成功时返回true，否则抛出异常。
  • descendingIterator(): 返回一个逆序迭代器，用于从队列尾部到头部遍历元素。
  • offerLast(E): 将指定的元素添加到队列的尾部，成功时返回true，否则抛出异常。
  • spliterator(): 返回一个分割迭代器，用于并行遍历队列中的元素。
  • addFirst(E): 将指定的元素添加到队列的头部。
  • removeLast(): 移除并返回队列尾部的元素，如果队列为空则抛出异常。
  • toArray(T[]): 将队列中的元素转换为指定类型的数组。
  • peekLast(): 返回队列尾部的元素但不移除它，如果队列为空则返回null。
  • pop(): 移除并返回队列头部的元素，如果队列为空则抛出异常。
  • clear(): 清空队列中的所有元素。
  • getFirst(): 返回队列头部的元素但不移除它，如果队列为空则抛出异常。
  • putFirst(E): 将指定的元素添加到队列的头部。
  • removeFirst(): 移除并返回队列头部的元素，如果队列为空则抛出异常。
  • getLast(): 返回队列尾部的元素但不移除它，如果队列为空则抛出异常。
  • offerFirst(E, long, TimeUnit): 将指定的元素添加到队列的头部，在指定的时间内等待空间可用，成功时返回true，否则返回false。
  • addLast(E): 将指定的元素添加到队列的尾部，成功时返回true，否则抛出异常。
  • poll(long, TimeUnit): 在指定的时间内从队列的头部移除并返回元素，如果在指定时间内没有元素可用则返回null。
  • toArray(): 将队列中的元素转换为Object类型的数组。

应用场景：

  1. 生产者消费者模型：生产者线程向队列中添加元素，消费者线程从队列中取出元素进行处理。
  2. 缓冲区：用于在生产者和消费者之间传递数据，提高数据处理的效率。
  3. 任务调度：将任务添加到队列中，然后由工作线程按顺序执行这些任务。

示例代码：

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.TimeUnit;

public class LinkedBlockingDequeExample {
    public static void main(String[] args) {
        LinkedBlockingDeque<String> deque = new LinkedBlockingDeque<>(5);

        // 生产者线程
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    deque.put("Element " + i);
                    System.out.println("Produced: Element " + i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        // 消费者线程
        new Thread(() -> {
            while (true) {
                try {
                    String element = deque.poll(2, TimeUnit.SECONDS);
                    if (element != null) {
                        System.out.println("Consumed: " + element);
                    } else {
                        break;
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

ConcurrentLinkedDeque

ConcurrentLinkedDeque<E> 是一个基于链表的并发双端队列，它实现了 Deque 接口。与 LinkedBlockingDeque 不同，ConcurrentLinkedDeque 是非阻塞的，即它在尝试从空队列中取出元素或向满队列中添加元素时不会阻塞线程。相反，它会抛出异常或者返回特定的值（例如 null）。

方法如下：
在这里插入图片描述

  • peek(): 返回队列头部的元素，但不移除它。如果队列为空，则返回null。
  • contains(Object): 检查队列是否包含指定的元素。
  • size(): 返回队列中的元素数量。
  • poll(): 移除并返回队列头部的元素。如果队列为空，则返回null。
  • offer(E): 将指定的元素添加到队列的尾部。成功时返回true，否则返回false（例如，当空间不足时）。
  • isEmpty(): 检查队列是否为空。
  • toArray(T[]): 将队列中的元素转换为指定类型的数组。
  • toArray(): 将队列中的元素转换为Object类型的数组。
  • add(E): 将指定的元素添加到队列的尾部。成功时返回true，否则抛出异常（例如，当空间不足时）。
  • addAll(Collection<E>): 将指定集合中的所有元素添加到队列的尾部。成功时返回true，否则抛出异常（例如，当空间不足时）。
  • spliterator(): 返回一个用于遍历队列元素的Spliterator对象。
  • remove(Object): 从队列中移除指定的元素（如果存在）。成功时返回true，否则返回false。
  • iterator(): 返回一个用于遍历队列元素的迭代器。

应用场景：

  1. 生产者消费者模型：生产者线程向队列中添加元素，消费者线程从队列中取出元素进行处理。
  2. 缓冲区：用于在生产者和消费者之间传递数据，提高数据处理的效率。
  3. 任务调度：将任务添加到队列中，然后由工作线程按顺序执行这些任务。

示例代码：

import java.util.concurrent.ConcurrentLinkedDeque;

public class ConcurrentLinkedDequeExample {
    public static void main(String[] args) {
        ConcurrentLinkedDeque<String> deque = new ConcurrentLinkedDeque<>();

        // 生产者线程
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                deque.add("Element " + i);
                System.out.println("Produced: Element " + i);
            }
        }).start();

        // 消费者线程
        new Thread(() -> {
            while (!deque.isEmpty()) {
                String element = deque.poll();
                if (element != null) {
                    System.out.println("Consumed: " + element);
                }
            }
        }).start();
    }
}
吴代庄
关注
专栏目录
Java并发编程面试题——线程安全（原子性、可见性、有序性）
二蛋的博客
02-16 4611
一、原子性高频问题 1.1 Java中如何实现线程安全? 1.2 CAS底层实现 1.3 CAS的常见问题 1.4 四种引用类型 + ThreadLocal的问题？ 二、可见性高频问题 2.1 Java的内存模型 2.2 保证可见性的方式 2.3 volatile修饰引用数据类型 2.4 有了MESI协议，为啥还有volatile？ 2.5 volatile的可见性底层实现 三、有序性高频问题 3.1 什么是有序性问题 3.2 volatile的有序性底层实现 四、synchronized高频问题 4.1
线程安全队列Queue
01-17
在项目启动时，开一个单线程来专门处理巡检任务的下发给巡检服务组件。使用BlockingQueue阻塞算法。BlockingQueue作为线程容器，可以为线程同步提供有力的保障。
线程安全的队列
weixin_30273175的博客
12-23 128
线程安全的队列 unit MyQueue; interface {$DEFINE MULTI_THREAD_QUEUE} //线程安全版本，如果不需要线程安全，请注释掉此行代码 {$IFDEF MULTI_THREAD_QUEUE}uses SyncObjs; // Windows;{$ENDIF} type TsfQueue = class private FCapa...
队列的线程安全
timeless的博客
10-20 6745
在Java多线程应用中，队列的使用率很高，多数生产消费模型的首选数据结构就是队列(先进先出)。Java提供的线程安全的Queue可以分为阻塞队列和非阻塞队列，其中阻塞队列的典型例子是BlockingQueue，非阻塞队列的典型例子是ConcurrentLinkedQueue，在实际应用中要根据实际需要选用阻塞队列或者非阻塞队列。 注：什么叫线程安全？这个首先要明确。线程安全就是说多线程访问同
java线程安全队列_Java ConcurrentLinkedQueue队列线程安全操作
weixin_42601547的博客
02-17 309
Java ConcurrentLinkedQueue队列线程安全操作代码示例：package async;import java.util.ArrayList;import java.util.List;import java.util.Queue;import java.util.concurrent.ConcurrentLinkedQueue;/**** 线程安全队列Queue实现计算科学...
学习Java第三十天--多线程之线程安全的集合
X池鱼
03-14 384
使用synchronized的集合、CopyOnWriteArrayList集合、CopyOnWriteArraySet集合、ConcurrentHashMap集合、Queue接口14.5 线程安全的集合14.5.1 线程安全集合图14.5.2 Collections中的工具方法14.5.3 CopyOnWriteArrayList14.5.4 CopyOnWriteArraySet14.5.5 ...
Jdk源码——AQS同步队列解析
等一杯咖啡的博客
12-26 510
前言 本文主要参考自《Java 并发编程的艺术》第五章内容，结合源码对书中内容进行分析补充。 I. Lock接口 在 Lock 接口出现之前，Java程序是靠 synchronized 关键字实现锁功能的，而 Java SE 5 之后，并发包中新增了 Lock 接口（以及相关实现类）用来实现锁功能，它提供了与 synchronized 关键字类似的同步功能，只是在使用时需要显式地获取和释放锁。...
Jdk源码——ArrayList解析
等一杯咖啡的博客
02-26 432
前言 本文主要针对 JDK1.8 的 ArrayList 源码进行解析，主要看源码注释，代码说明了全部实现细节。 I. 继承结构 ArrayList 的继承结构如下图所示，下面我们进行一一解析。 Serializable Serializable 接口是启用其序列化功能的接口，接口定义如下： public interface Serializable { } 实现 java.io.Serial...
Nashorn与JDK8——动态语言在JVM上的高性能实现.pdf
09-18
Nashorn的目标是提供一个高性能的JavaScript执行环境，它可以利用Java平台的各种资源和特性，如成熟的垃圾回收（GC）、即时编译（JIT）编译器、多线程支持以及丰富的标准库和第三方库。 Nashorn的出现主要是为了...
重学设计模式——线程安全的观察者模式
ApkCore的专栏
06-15 761
线程安全的观察者模式 先来说下观察者模式，其实在Android开发中，我们使用观察者模式的时候还是非常多的，无论是广播使用的发布-订阅模式，还是listview的notifyDataSetChanged，或者是RxJava的使用，都是观察者模式的运用。今天就来重新看一下观察者模式。 概念 订阅模式，又称观察者模式。定义对象间一种一对多的依赖关系（注册），使得当一个对象改变状态后，则所有依赖它的对象...
线程安全型队列的实现
01-02
操作系统课程设计线程安全型队列，利用读者优先机制实现互斥。
python thread_生产者消费者模式
X1669169588的博客
12-03 968
from Queue import Queue import time import threading #生产者消费者模式是线程间通信的一种应用 #在使用数据结构的时候确定是否是线程安全，Queue本身是线程安全的 #list([]) Dict({}) 都不是线程安全的 def set_value(q): index = 0 while True: q.pu...
线程安全队列
BJUT_bluecat的博客
06-24 257
// // main.cpp // threadsafe_queue // // Created by 蓝猫 on 2019/6/24. // Copyright © 2019年 蓝猫. All rights reserved. // #include <iostream> #include <queue> #include <mutex> #inc...
java队列——queue详细分析
weixin_30443895的博客
11-22 6693
Queue： 基本上，一个队列就是一个先入先出（FIFO）的数据结构 Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Deque接 口。 Queue的实现 1、没有实现的阻塞接口的LinkedList： 实现了java.util.Queue接口和java.util.AbstractQueue接口　　内置的不阻塞队列： Pri...
一文弄懂Java线程安全队列
Haiwi-Song
03-01 7919
文章目录一、分类二、BlockingQueue 阻塞队列三、ConcurrentLinkedQueue 非阻塞队列 一、分类 java中所有队列都继承至java.util.Queue接口，该接口定义了以下三组方法： 方法名 抛出异常 返回特殊值 插入 add(e) offer(e) 移除 remove() poll() 检查 element() peek() Java提...
线程安全的队列写法
菜鸟の轨迹
10-02 745
首先，互斥量这种线程相关的内容是平台相关的，我假设你用的是windows平台开发。 其次，说明一下我的开发环境，vs2008，控制台程序，空的工程。 最后给你贴代码，分文件来看。 ===头文件QueueNode.h=== ===你需要的节点数据可能不是整数，只要将typedef int QUEUEDATA这一句的int换成你想要的类型即可，但要注意，这个类型必须实现赋值操作符重载，相等
线程安全的并发队列
赶路人儿
03-10 7632
在并发编程中，我们可能经常需要用到线程安全的队列，java为此提供了两种模式的队列：阻塞队列和非阻塞队列。其中阻塞队列的典型例子是BlockingQueue，非阻塞队列的典型例子是ConcurrentLinkedQueue，在实际应用中要根据实际需要选用阻塞队列或者非阻塞队列。 注：什么叫线程安全？线程安全就是说多线程访问同一代码，不会产生不确定的结果。 一、阻塞队列： LinkedBloc...
java-队列(线程安全)
杨杨杨~~的博客
03-28 1631
java 线程安全 队列 概念: 只允许在一端插入数据操作，在另一端进行删除数据操作的特殊线性表；进行插入操作的一端称为队尾（入队列），进行删除操作的一端称为队头（出队列）；队列具有先进先出（FIFO）的特性。 直接上代码: public class ListDL { private static ConcurrentLinkedDeque<Str...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

吴代庄

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

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

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

打赏作者

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

抵扣说明：

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

余额充值