并发集合 CopyOnWrite

最新推荐文章于 2025-08-08 11:34:53 发布
最新推荐文章于 2025-08-08 11:34:53 发布
阅读量115 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： concurrent 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/iteye_9601/article/details/81966502

CopyOnWriteArrayList

内部结构比较简单；

包含了一个可重入锁：

 

transient final ReentrantLock lock = new ReentrantLock();

一个易变的对象类型数组。它是具体包含数据的主角，只是其内容总是在数据发生变化时，集体哗变：

 

private volatile transient Object[] array;

 

增删操作会使用Arrays.copyOf或者System.arraycopy，因此较ArrayList会慢。

 

查找很快，既是对内部数组的数据定位。较之ArrayList，没有校验边界，因为并发下，边界有可能发生改变。

 

public E get(int index) {
	return (E) (getArray()[index]);
}
 

CopyOnWriteArraySet

Java 并发集合：CopyOnWrite 写时复制集合介绍
栗筝i的博客
07-02 6347
写时复制（Copy-on-Write，简称COW）是一种计算机程序设计领域的优化策略。其核心思想是：如果有多个调用者同时请求相同资源（如内存或磁盘上的数据存储），他们会共同获取相同的指针指向相同的资源，直到某个调用者试图修改资源的内容时，系统才会真正复制一份专用副本给该调用者，而其他调用者所见到的最初的资源仍然保持不变。这一过程对其他的调用者都是透明的。当对容器进行写操作（这里的写可以理解为 “增、删、改”）时，为了避免读写操作同时进行而导致的线程安全问题。
32、Java并发编程：并发集合与并行流的深入解析
view3的博客
06-27 15
本文深入解析了Java中的并发集合与并行流，详细介绍了并发集合的应用场景、常见类及其使用方法，并探讨了并行流的创建与性能优化。文章还结合实际示例，分析了并发编程的综合应用与注意事项，帮助开发者提高多线程环境下的程序性能和稳定性。
JAVA-CopyOnWrite并发集合
m0_62943934的博客
06-15 1235
概括为"写时复制"，通俗的讲是写数据的时候弄出一个新的数组，然后讲旧的数据拷贝过去，更新后再将引用指向新数组。这样在添加删除元素时就不会影响旧数组的读取了，确保高并发时读的效率，但是存在延时。下面以和为例对系列的集合进一步讲解。系列集合通过写时复制机制实现线程安全，适用于读操作频繁且写操作较少的场景。虽然写操作的开销较大，但在读操作占多数的应用中，集合可以提供高效且线程安全的性能。在中，移除元素的操作与添加元素类似，通过复制数组并在新数组上进行操作来实现线程安全。
第十九章 Java多线程--并发集合-CopyOnWriteArrayList
Lin_Miao_09的博客
11-21 768
CopyOnWriteArrayList 进行写操作（如添加、删除元素）时，它会创建一个新的数组副本，并在新数组上进行操作，最后将引用指向新的数组。这种机制使得 CopyOnWriteArrayList 在读多写少的场景下表现优异，因为读操作不需要加锁，而写操作虽然需要创建新数组，但频率较低。
（十）并发集合——CopyOnWrite集合
qq_32076957的博客
12-15 259
CopyOnWrite
java 并发集合_Java并发集合
weixin_34910865的博客
02-16 1634
Java并发集合并发集合实现1JDK1.5的出现，对于集合并发编程来说，java developer有了更多的选择。不过，在JDK1.5之前，Java也还是提供了一些解决方案。(1)最为简单直接的就是在程序中我们自己对共享变量进行加锁。不过，缺点也显而易见，手动实现线程安全间接增加了程序的复杂度，以及代码出错的概率---例如：线程死锁的产生；(2)我们还可以使用Java集合框架中的Vector、H...
Java并发集合
weixin_54879811的博客
04-27 906
Java并发集合各具特点。ConcurrentHashMap：JDK7用分段锁，JDK8改用CAS加同步锁，链表转红黑树，提升高并发读写和并行扩容性能。CopyOnWriteArrayList/Set：写时复制，写锁定整表，读操作无锁，适合读多写少。BlockingQueue支持阻塞、超时与有界/无界，常用于生产者-消费者模式。无锁集合基于CAS与跳表，读写无锁，确保高效并发。选型时应结合读写频率、容量需求、有序性、延迟等因素，权衡性能与线程安全。
java并发集合有哪些_java中常见并发集合有哪些？详细解析
weixin_39917046的博客
02-13 1051
关于java中有关集合的知识点，相信大家还是有所了解的。集合中所包含的知识点是非常丰富的，而且可以细分为很多类型。今天就来为大家介绍一下并发集合的有关知识，并且用实际代码为大家展示，一起来看看吧。首先我们需要知道的是，并发集合是jdk5.0重要的特性，增加了并发包java.util.concurrent.*。Java内存模型、volatile变量及AbstractQueuedSynchronize...
JAVA集合之并发集合
胡兵(Java)
02-21 625
JAVA并发下，可选择的并发集合类
CopyOnWrite并发集合
bit-cafe
02-05 663
Copy-On-Write简称COW，是一种用于程序设计中的优化策略。其基本思路是，从一开始大家都在共享同一个内容，当某个线程想要修改这个内容的时候，才会真正把内容Copy出去形成一个新的内容然后再改，这是一种延时懒惰策略。从JDK1.5开始Java并发包里提供了两个使用CopyOnWrite机制实现的并发容器,它们是CopyOnWriteArrayList和CopyOnWriteArraySet
使用 CopyOnWrite 实现并发写操作
实践求真知
03-19 455
一点睛 同步类容器是一种串行化、线程安全的容器，在特定情况下对资源加锁。因此在多线程环境中，会降低应用的吞吐量，另外，同步容器类在早期设计时没有考虑一些并发问题，因此在使用时经常会出现ConcurrentModificationException等并发异常。 同步类容器 并发类容器 HashTable ConcurrentHashMap Vector CopyOnWriteArrayL...
多线程并发集合资料.zip
05-18
在Java编程中，多线程并发集合是程序员在开发高并发应用时必须掌握的重要概念。这些集合类的设计目的是为了在多线程环境下提供高效、安全的数据共享，避免数据竞争和死锁等问题。以下是对给定文件中涉及知识点的详细...
数据结构2.（双向链表，循环链表及内核链表）
2401_89312016的博客
08-05 637
本文详细介绍了三种链表的实现方法：双向链表、循环链表和内核链表。双向链表部分包含节点定义、创建、头插/尾插法、遍历、查找、修改、删除等操作实现；循环链表在双向链表基础上增加了循环特性，调整了遍历条件；内核链表部分分析了Linux内核中的链表实现，包括节点定义、初始化、插入/删除操作以及各类遍历宏定义。全文通过代码示例展示了链表的核心操作，重点比较了不同链表类型在实现上的差异，特别是循环链表和内核链表在结构设计和操作实现上的优化技巧。
数据结构04 栈和队列
LI1109hd的博客
08-05 268
/队列: 先进先出。
【数据结构初阶】--顺序表（二）
yhrxh_ymq的博客
08-05 831
本文详细讲解了顺序表的实现方法，重点介绍了尾插、头插、尾删和头删四个核心操作。内容包含：1）尾插操作的动态扩容机制，采用2倍扩容策略；2）头插操作需要整体后移元素；3）尾删只需修改size值；4）头删需要前移元素。文中提供了完整的C语言实现代码，并通过测试用例验证了各功能的正确性。最后分析了时间复杂度：尾插/删为O(1)，头插/删为O(n)，说明顺序表更适合频繁操作尾部数据的场景。作者预告后续将继续完善顺序表的其他操作接口。
数据结构——图及其C++实现 多源最短路径 FloydWarshall算法
学习日记
08-06 933
前两篇学习的Dijkstra算法和Bellman-Ford算法都是用来求解图的单源最短路径，即从图中指定的一个源点出发到图中其他任意顶点的最短路径。Dijkstra算法不能求解带有负权重的图的最短路径，而Bellman-Ford算法弥补了这个缺点。本篇文章再来见识一下一个求解多源最短路径的算法——Floyd-Warshall算法。多源最短路径–Floyd-Warshall算法Floyd-Warshall算法是一种解决多源最短路径问题（任意两点间的最短路径）的算法。
嵌入式 - 数据结构：循环链表和内核链表
m0_74911141的博客
08-05 490
/ 数据域// 前驱指针// 后继指针} linknode;// 首尾自环Linux 内核中通过// 后继指针// 前驱指针初始化初始化头节点，使其首尾自环；插入（头插）、（尾插）；删除从链表中移除节点；遍历遍历数据元素，其中member为数据结构中成员的名称；数据定位通过节点指针ptr找到数据结构的首地址（核心宏，通过指针运算实现）。使用内核链表时，需在自定义数据结构中嵌入// 示例：定义一个包含内核链表节点的进程结构int pid;// 进程ID// 进程名。
（数据结构）链表
最新发布
2402_83411382的博客
08-08 666
本文详细介绍了单向链表和双向链表的实现原理及基本操作。在单向链表部分，讲解了链表结构定义、打印、尾插/头插、尾删/头删等操作的实现方法，重点分析了指针传递问题（需使用二级指针修改头节点）。双向链表部分则展示了带头双向循环链表的结构优势，详细说明了初始化、插入、删除等操作的实现逻辑，强调通过画图辅助理解指针操作。文章还对比了两种链表的特点：单向链表结构简单但功能有限，适合作为子结构；双向链表结构复杂但操作高效，适合单独存储数据。所有代码示例都配有详细注释，帮助理解指针操作和边界条件处理。
数据结构：二叉树
2501_91498265的博客
08-07 539
2.广度优先遍历（BFS）：层序遍历（1、2、3、4、5、6、7、8、9、10、11、12）2.完全二叉树：二叉树的编号（如果节点编号为n，左孩子编号2n，右孩子编号为2n+1），2.二叉树节点类型：叶子节点、只有左孩子、只有孩子、左右孩子都有。2.非线性结构：描述数据一对多（树）、多对多（图）3.后继（子孙）：该节点可以后续访问到哪些节点。2.前驱（祖先）：由那个节点可以访问到该节点。左右（1、2、4、8、9、5、10、11、3、6、12、7）右（8、4、9、2、10、5、11、1、12、6、3、7）
Java并发 集合并发容器
08-08
<think>我们正在讨论Java并发包中的并发容器。根据引用[1]和[2]，Java并发包提供了一系列线程安全的容器，用于解决多线程环境下的共享数据问题。这些容器可以分为几类：线程安全的List、Set、Map以及队列（队列已在之前的问题中详细讨论，这里主要关注非队列的容器）。 分类如下： 1. List: - CopyOnWriteArrayList: 基于写时复制技术，适用于读多写少的场景。 2. Set: - CopyOnWriteArraySet: 基于CopyOnWriteArrayList实现，同样适用于读多写少的场景。 - ConcurrentSkipListSet: 基于跳表实现的有序集合，支持并发访问。 3. Map: - ConcurrentHashMap: 高并发环境下使用的HashMap，通过分段锁（JDK7）或CAS+synchronized（JDK8）实现线程安全。 - ConcurrentSkipListMap: 基于跳表实现的有序Map，支持并发访问。 4. 队列（Queue/Deque）: - 上一问题已详细讨论，包括阻塞队列、非阻塞队列等，这里不再重复。 下面我们详细说明每个容器的特点和使用场景。 一、List容器 1. CopyOnWriteArrayList - 原理：写操作（add, set, remove等）时，会复制底层数组，修改在新数组上进行，最后将新数组替换旧数组。读操作无锁，直接访问当前数组。 - 特点：读操作非常快，写操作因为需要复制数组，所以开销较大。适合读多写少的场景。 - 注意：由于读操作不会阻塞，所以可能读到旧数据，因此适合对数据一致性要求不高的场景。 - 示例代码： ```java CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>(); // 写操作（会复制数组） list.add("item1"); // 读操作（无锁） String item = list.get(0); ``` 二、Set容器 1. CopyOnWriteArraySet - 原理：内部使用CopyOnWriteArrayList实现，因此特性与CopyOnWriteArrayList类似。 - 特点：同样适用于读多写少的场景，写操作开销大，读操作无锁。 - 注意：由于基于CopyOnWriteArrayList，所以它不适用于元素数量很大的集合，因为每次写操作都要复制整个数组。 2. ConcurrentSkipListSet - 原理：基于ConcurrentSkipListMap实现，使用跳表数据结构，保证元素的有序性（自然顺序或通过Comparator）。 - 特点：支持并发的插入、删除和查找操作，且操作的时间复杂度为$O(\log n)$。 - 适用场景：需要有序且并发的集合。 三、Map容器 1. ConcurrentHashMap - 原理：在JDK7中，使用分段锁（Segment）来减小锁的粒度，每个段独立加锁。在JDK8中，改为使用CAS+synchronized来保证并发安全，并且当链表长度超过阈值时转换为红黑树，以提高查找效率。 - 特点：高并发环境下性能优异，比Hashtable和Collections.synchronizedMap()性能好很多。 - 适用场景：高并发且需要键值对存储的场景。 - 示例代码： ```java ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>(); map.put("key1", 1); int value = map.get("key1"); ``` 2. ConcurrentSkipListMap - 原理：基于跳表（Skip List）实现的有序Map。跳表是一种可以快速查找、插入、删除的数据结构，通过多级索引实现。 - 特点：支持高并发的有序Map，所有操作都是线程安全的，且操作的时间复杂度为$O(\log n)$。 - 适用场景：需要有序且并发的键值对存储，例如排行榜等。 四、队列容器（简要提及，因为之前问题已覆盖） - 包括BlockingQueue的实现（如ArrayBlockingQueue, LinkedBlockingQueue, PriorityBlockingQueue等）和非阻塞队列（如ConcurrentLinkedQueue, ConcurrentLinkedDeque）等。 总结表格： | 容器类型 | 实现类 | 特点 | 适用场景 | |---------|--------|------|---------| | List | CopyOnWriteArrayList | 读无锁，写复制数组 | 读多写少，如监听器列表 | | Set | CopyOnWriteArraySet | 基于CopyOnWriteArrayList，读多写少 | 读多写少的集合 | | Set | ConcurrentSkipListSet | 基于跳表，有序，并发安全 | 需要有序的并发集合 | | Map | ConcurrentHashMap | 分段锁或CAS+synchronized，高并发 | 高并发键值存储，如缓存 | | Map | ConcurrentSkipListMap | 跳表实现，有序 | 需要有序的并发键值存储 | 注意：使用这些并发容器时，需要根据具体场景选择。例如，如果对读性能要求极高且写操作很少，可以选择CopyOnWrite系列；如果对并发写要求高，则选择ConcurrentHashMap或ConcurrentSkipListMap。 常见问题： 1. 如何选择List容器？ - 如果需要频繁修改（写操作），则不建议使用CopyOnWriteArrayList，因为写操作会复制整个数组。此时，可以考虑使用Collections.synchronizedList()，但要注意其性能不如CopyOnWriteArrayList在读多写少场景下的表现。 2. ConcurrentHashMap在JDK7和JDK8中的区别？ - JDK7：使用分段锁（Segment），每个段相当于一个小的HashMap，锁的粒度是段。 - JDK8：使用Node数组+链表+红黑树，锁的粒度是每个数组元素（桶），使用CAS和synchronized来保证并发安全。当链表长度大于8且数组长度超过64时，链表转换为红黑树。 3. 为什么需要ConcurrentSkipListMap？ - 因为ConcurrentHashMap是无序的，当需要有序的Map时，可以使用ConcurrentSkipListMap。它提供了并发环境下的有序映射。 示例代码：ConcurrentHashMap的线程安全操作 ```java ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>(); // 多个线程可以安全地执行put操作 new Thread(() -> map.put("key2", 2)).start(); new Thread(() -> map.put("key3", 3)).start(); // 使用原子更新方法 map.computeIfAbsent("key4", k -> 4); ``` 最后，注意并发容器并不能保证所有复合操作都是原子性的，例如： ```java // 非原子操作 if (!map.containsKey("key")) { map.put("key", 1); } // 应该使用原子方法 map.putIfAbsent("key", 1); ``` 因此，使用并发容器时，应尽量使用其提供的原子方法（如putIfAbsent, compute, computeIfAbsent, merge等）来避免竞态条件。 相关问题： 1. CopyOnWriteArrayList的写操作是如何保证线程安全的？ 2. ConcurrentHashMap在JDK8中是如何实现扩容的？ 3. 跳表（Skip List）的数据结构是怎样的？为什么它适合并发？ 4. 并发容器和普通容器通过Collections.synchronizedXXX包装的容器有什么区别？</think>### Java 并发包中的并发容器详解 Java 并发包（`java.util.concurrent`）提供了多种线程安全的容器类，用于解决多线程环境下的数据共享问题。这些容器通过高效的同步机制（如 CAS、写时复制、分段锁等）平衡线程安全与性能。以下是主要分类及实现： --- #### 一、线程安全 List | 实现类 | 核心机制 | 特点 | 适用场景 | |-------------------------|----------------------|----------------------------------------------------------------------|------------------------------| | **`CopyOnWriteArrayList`** | 写时复制 (Copy-on-Write) | 写操作复制新数组，读操作无锁；读多写少时性能高，写操作开销大[^1] | 监听器列表、配置管理等低频写场景 | | **`Collections.synchronizedList`** | 互斥锁 | 包装普通`ArrayList`，所有方法用`synchronized`同步；简单但吞吐量低 | 兼容旧代码的简单同步需求 | **示例**： ```java // 高并发读场景 List<String> safeList = new CopyOnWriteArrayList<>(); safeList.add("data"); // 写时复制 String data = safeList.get(0); // 无锁读 // 简单同步 List<String> syncList = Collections.synchronizedList(new ArrayList<>()); ``` --- #### 二、线程安全 Set | 实现类 | 核心机制 | 特点 | 适用场景 | |-------------------------|----------------------|----------------------------------------------------------------------|------------------------------| | **`CopyOnWriteArraySet`** | 写时复制 | 基于`CopyOnWriteArrayList`实现，特性类似[^1] | 读多写少的集合操作 | | **`ConcurrentSkipListSet`** | 跳表 (Skip List) | 有序集合（自然序或`Comparator`），CAS无锁实现，高并发插入/删除 | 需排序的高并发集合（如排行榜）| | **`Collections.synchronizedSet`** | 互斥锁 | 包装普通`HashSet`，方法全同步 | 简单同步需求 | **示例**： ```java Set<Integer> leaderboard = new ConcurrentSkipListSet<>(); leaderboard.add(100); // 并发插入有序集合 ``` --- #### 三、线程安全 Map | 实现类 | 核心机制 | 特点 | 适用场景 | |-------------------------|----------------------|----------------------------------------------------------------------|------------------------------| | **`ConcurrentHashMap`** | 分段锁 + CAS (JDK7)<br>CAS + `synchronized` (JDK8+) | 高并发读写，锁粒度细；JDK8 引入红黑树优化哈希冲突 | 缓存、会话存储等高并发 K-V 场景 | | **`ConcurrentSkipListMap`** | 跳表 | 有序 Map，支持并发排序和范围查询 | 需排序的并发字典（如范围检索） | | **`Collections.synchronizedMap`** | 互斥锁 | 包装普通`HashMap`，全方法同步 | 简单同步需求 | **`ConcurrentHashMap` 关键优化**： - JDK8 取消分段锁，改用 `Node` + CAS + `synchronized` 锁单个桶（Bucket） - 哈希冲突时链表转红黑树（阈值：链表长度 ≥ 8） - 支持原子方法：`compute()`, `merge()`, `search()` 等[^1] **示例**： ```java ConcurrentHashMap<String, Integer> cache = new ConcurrentHashMap<>(); // 原子更新 cache.compute("key", (k, v) -> (v == null) ? 1 : v + 1); ``` --- #### 四、线程安全队列（Queue/Deque） > 详见上一问题总结，核心实现包括： > - **阻塞队列**：`ArrayBlockingQueue`, `LinkedBlockingQueue` > - **非阻塞队列**：`ConcurrentLinkedQueue`, `ConcurrentLinkedDeque` > - **特殊队列**：`DelayQueue`, `PriorityBlockingQueue`[^2][^3] --- ### 并发容器选择指南 | 需求场景 | 推荐容器 | |------------------------|-----------------------------------| | 高频读 + 低频写 | `CopyOnWriteArrayList`/`CopyOnWriteArraySet` | | 高并发 K-V 存储 | `ConcurrentHashMap` | | 有序集合 + 高并发 | `ConcurrentSkipListSet`/`ConcurrentSkipListMap` | | 生产者-消费者模型 | `ArrayBlockingQueue`（有界） | | 定时任务调度 | `DelayQueue` | --- ### 常见问题解决方案 #### ❌ 复合操作非原子性 ```java // 错误：contains + add 非原子 if (!set.contains(item)) { set.add(item); } // 正确：使用 ConcurrentHashMap 的原子方法 ConcurrentHashMap<String, Boolean> map = new ConcurrentHashMap<>(); map.putIfAbsent("key", true); ``` #### ❌ `CopyOnWriteArrayList` 写性能差 ```java // 避免频繁写操作：批量添加 List<String> batchData = Arrays.asList("a", "b", "c"); safeList.addAll(batchData); // 减少复制次数 ``` #### ❌ 遍历时并发修改 ```java // ConcurrentHashMap 迭代器弱一致性（不抛异常） ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>(); map.forEach((k, v) -> process(k, v)); // 安全遍历 ``` --- ### 总结 Java 并发容器的核心设计思想： 1. **降低锁粒度**：如 `ConcurrentHashMap` 的分段锁/CAS 优化。 2. **读写分离**：如 `CopyOnWriteArrayList` 写时复制。 3. **无锁算法**：如 `ConcurrentSkipListMap` 的跳表+CAS。 4. **专用场景优化**：如 `DelayQueue` 的延迟调度。 > **关键原则**： > - 优先选择并发专用容器（如 `ConcurrentHashMap`），而非 `Collections.synchronizedXXX` 包装类。 > - 根据读写比例选择数据结构（如读多写少用 `CopyOnWriteArrayList`）。 > - 有界性设计防止资源耗尽（如队列显式设置容量）。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值