Collections.synchronizedList与CopyOnWriteArrayList的区别

CopyOnWriteArrayList与synchronizedList对比
最新推荐文章于 2025-06-12 20:00:00 发布
原创 最新推荐文章于 2025-06-12 20:00:00 发布 · 805 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言 #后端

本文对比了CopyOnWriteArrayList与Collections.synchronizedList两种线程安全集合的实现方式，介绍了CopyOnWriteArrayList的设计思想及应用场景，并讨论了其内存占用问题。

  • CopyOnWriteArrayList：执行修改操作时，会拷贝一份新的数组进行操作（add、set、remove等)，代价十分昂贵，在执行完修改后将原来集合指向新的集合来完成修改操作，源码里面用ReentrantLock可重入锁来保证不会有多个线程同时拷贝一份数组

    • 场景：读高性能，适用读操作远远大于写操作的场景中使用(读的时候是不需要加锁的，直接获取，删除和增加是需要加锁的, 读多写少)

  • Collections.synchronizedList：线程安全的原因是因为它几乎在每个方法中都使用了synchronized同步*锁

    • 场景：写操作性能比CopyOnWriteArrayList好，读操作性能并不如CopyOnWriteArrayList

  • CopyOnWriteArrayList的设计思想是怎样的,有什么缺点？

    设计思想：读写分离+最终一致

    缺点：内存占用问题,写时复制机制,内存里会同时驻扎两个对象的内存，旧的对象和新写入的对象,如果对象大则容易发生Yong GC和Full GC

CopyOnWriteArrayList与Collections.synchronizedList
weixin_30652271的博客
03-18 447
1、CopyOnWriteArrayList 1.CopyOnWriteArrayList（字译名称：写时复制），它可以看成是线程安全且读操作无锁的ArrayList。 2.使用场景： 读操作远远大于写操作，比如有些系统级别的信息，往往需要加载或者修改很少的次数，但是会被系统内的所有模块频繁的访问。 3.原理： CopyOnWriteArrayList容器允许并发读，读操作时无锁的，性能...
synchronizedList和CopyOnWriteArrayList
写bug的小哥哥
09-18 704
1.synchronizedList synchronizedList能把所有 List 接口的实现类转换成线程安全的List，相比 Vector 有更好的扩展性和兼容性 public void test(){ ArrayList<String> list = new ArrayList<>(); List<String> synchronizedList = Collections.synchronizedList(list);
Collections.synchronizedList 、CopyOnWriteArrayList、Vector介绍、源码浅析与性能对比【文末福利】
Nauyus的技术博客
02-01 4648
本文简要的分析了下Collections.synchronizedList 、CopyOnWriteArrayList、Vector线程安全的实现机制并对它们的读，写，迭代性能进行了对比。
CopyOnWriteArrayList 与 Collections.synchronizedList
qq_35779969的博客
09-10 506
疑问点： 前者有两个get(int index)重载方法，怎么判断什么时候用哪个？ 源码对比： CopyOnWriteArrayList 在写时会加锁，同时操作时会拷贝一个新的数组以存放新的字段 public void add(int index, E element) { final ReentrantLock lock = l.lock; lock.lock(); try { ..
Collections.synchronizedList & CopyOnWriteArrayList
w592376568的博客
01-12 698
ArrayList是非线性安全，即在一方在便利列表，而另一方在修改列表时，会报ConcurrentModificationException错误。而这不是唯一的并发时容易发生的错误，在多线程进行插入操作时，由于没有进行同步操作，容易丢失数据。              Vector是一个线程安全的列表，采用数组实现。其线程安全的实现方式是对所有操作都加上了synchronized关键字，这种
Java 的 CopyOnWriteArrayList 和 Collections.synchronizedList 有什么区别？分别有什么优缺点？
2302_81141145的博客
02-07 1520
的多维度解析，既能体现对技术细节的掌控力，又能展现架构设计中的权衡思维。建议在面试中结合白板画COW内存变化示意图，增强技术表达的说服力。考虑ConcurrentLinkedQueue或其他并发结构。CopyOnWriteArrayList+容量监控。synchronizedList+分段锁。在微服务配置中心实现中，使用。需要线程安全List?
Collections.synchronizedList
04-17
这个链接的内容可能包括最佳实践、避免的陷阱以及与其他线程安全集合类（如CopyOnWriteArrayList或ConcurrentLinkedQueue）的比较。 在Java中，了解如何正确地处理并发集合是非常关键的技能，因为错误的使用可能会...
List系列：Collections.synchronizedList与CopyOnWriteArrayList比较
流的博客
09-03 1026
1.Collections.synchronizedList Collections.synchronizedList可以将一个不安全的list变成安全的list。 ArrayList arrayList = new ArrayList(); List list2 = Collections.synchronizedList(arrayList); add方法：通过关键字synchronize...
Collections.synchronizedList与CopyOnWriteArrayList比较
weixin_30607029的博客
08-26 413
1.单线程方式 2.多线程版本，不安全的 ArrayList 3.多线程版本，线程安全，CopyOnWriteArrayList()方式 4.多线程版本，线程安全，Collections.synchronizedList方式 1 import java.util.ArrayList; 2 import java.util.Collections; 3 im...
Java中的Collections.synchronizedList()和CopyOnWriteArrayList
RollingCode_999的博客
02-24 2217
我们知道在多线程的环境下并不是线程安全的，那如果我们需要在多线程的场景下使用连续存储并且数据具有有序性，可直接快速访问元素的集合时，可以使用或者替代Collections.synchronizedList()用于将普通的List转化为线程安全的同步列表。其底层是基于，通过包装将原始列表转换为对其所有操作都添加同步锁，来确保多线程的环境下的安全性。
Java集合：CopyOnWriteArrayList与SynchronizedList
a447942008的博客
04-10 431
CopyOnWriteArrayList 首先提两点： 1、CopyOnWriteArrayList位于java.util.concurrent包下，可想而知，这个类是为并发而设计的 2、CopyOnWriteArrayList，顾名思义，Write的时候总是要Copy，也就是说对于CopyOnWriteArrayList，任何可变的操作（add、set、remove等等）都是伴随...
一文搞懂：CopyOnWriteArrayList vs SynchronizedList，区别、优缺点全解析
全栈开发工程师
05-09 1798
根据你的场景选择：读多写少→选后者；读写均衡或强一致性→选前者。理解原理后，再也不怕用错啦！不是线程安全的，多线程下同时读写会出问题（比如。在Java中，普通的。
Collections.synchronizedMap()与ConcurrentHashMap的区别
热门推荐
lanxiangru的博客
12-07 3万+
Collections.synchronizedMap()与ConcurrentHashMap主要区别是：Collections.synchronizedMap()和Hashtable一样，实现上在调用map所有方法时，都对整个map进行同步，而ConcurrentHashMap的实现却更加精细，它对map中的所有桶加了锁。所以，只要要有一个线程访问map，其他线程就无法进入map，而如果一个线程在访问ConcurrentHashMap某个桶时，其他线程，仍然可以对map执行某些操作。这样，Concurre
Java面试必备：Java中的CopyOnWriteArrayList与Collections.synchronizedList比较
qq_58299462的博客
06-12 829
在多线程编程中，线程安全的集合是保证程序正确性的关键。Java提供了多种实现线程安全列表的方式，其中`CopyOnWriteArrayList`和`Collections.synchronizedList`是两种常用的选择。本文将深入比较这两种实现方式的区别、优缺点及适用场景。
Collections.synchronizedList和CopyOnWriteArrayList的选择
是狮不是猿
04-15 1114
背景 在多线程环境下ArrayList是线程不安全的，所以需要使用线程安全的List，我第一时间使用的是Collections.synchronizedList(new Arraylist<>()),但是在实际使用过程中却发生了安全事件。 测试 当前存在一个类IntegerList，该类对象在多线程环境中添加元素和获取获取 public class IntegerList { final private List<Integer> integerList; pub
线程安全的list之synchronizedList和CopyOnWriteArrayList
刘辉的专栏
06-20 1465
在上篇文章中我们已经介绍了其他的一些list集合，如ArrayList、linkedlist等。不清楚的可以看下上篇文章一文彻底了解List集合 但是向ArrayList这些会出现线程不安全的问题，我们该怎样解决呢？接下来就是要介绍我们线程安全的list集合synchronizedList和CopyOnWriteArrayList。 一、synchronizedList synchroniz...
CopyOnWriteArrayList与Collections.synchronizedList的性能对比
luotuomianyang的博客
08-02 780
一 、ArrayList        ArrayList是非线性安全，此类的 iterator 和 listIterator 方法返回的迭代器是快速失败的：在创建迭代器之后，除非通过迭代器自身的 remove 或 add 方法从结构上对列表进行修改，否则在任何时间以任何方式对列表进行修改，迭代器都会抛出 ConcurrentModificationException。即在一方在便利列表
java多线程示例：Arraylist的线程安全实现方式Collections.synchronizedList和new CopyOnWriteArrayList
weixin_37549458的博客
07-02 509
package com.example.test; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.concurrent.CopyOnWriteArrayList; public class TestArrayListSafe { public static void main(String args[]){ // List<I
Collections.synchronizedList(); CopyOnWriteArrayList区别
最新发布
08-08
<think>我们正在讨论Collections.synchronizedList()和CopyOnWriteArrayList的区别。根据引用内容，我们可以从以下几个方面进行对比： 1. **线程安全实现机制**： - `Collections.synchronizedList()`：通过在每个方法上使用synchronized关键字来实现线程安全。这意味着每次只有一个线程可以访问该列表的方法（读或写都需要获取锁）[^1][^2][^3]。 - `CopyOnWriteArrayList`：使用写时复制（Copy-On-Write）技术。当进行写操作（添加、修改、删除）时，它会复制底层数组，修改在新数组上进行，然后替换引用。读操作则直接在旧数组（快照）上进行，无需加锁[^1][^2][^4]。 2. **性能特点**： - **读操作**： - `CopyOnWriteArrayList`：读操作不需要加锁，因此读性能非常高，尤其是在读多写少的场景中[^1][^2][^4]。 - `Collections.synchronizedList()`：读操作需要获取锁，因此读性能相对较低（因为存在锁竞争）[^1][^2]。 - **写操作**： - `CopyOnWriteArrayList`：写操作需要复制整个数组，因此写性能较差（尤其是在数据量大时）[^1][^2][^4]。 - `Collections.synchronizedList()`：写操作只需要获取锁，不需要复制数组，因此写性能相对较好（但锁竞争激烈时性能会下降）[^1][^2]。 3. **内存使用**： - `CopyOnWriteArrayList`：在写操作时会复制整个数组，因此内存占用较高（尤其是在写操作频繁时）[^2][^4]。 - `Collections.synchronizedList()`：内存占用较低，因为它只是对原有列表的包装，没有额外的数组复制[^2]。 4. **迭代器行为**： - `CopyOnWriteArrayList`：迭代器是弱一致性的。迭代器创建时持有当时数组的快照，因此不会抛出`ConcurrentModificationException`，但迭代过程中可能无法反映最新的修改[^1][^2][^5]。 - `Collections.synchronizedList()`：迭代器是快速失败的。在迭代过程中如果列表被修改（除了通过迭代器自身的remove或add方法），会立即抛出`ConcurrentModificationException`。因此，在迭代时必须手动同步整个迭代过程[^1][^2][^5]。 5. **复合操作的原子性**： - `Collections.synchronizedList()`：虽然单个操作是线程安全的，但复合操作（如“检查再执行”：先检查是否存在再添加）需要外部同步（synchronized块）来保证原子性[^4]。 - `CopyOnWriteArrayList`：由于每次写操作都会复制新数组，因此其部分复合操作（如`addIfAbsent()`）是原子操作，无需额外同步[^4]。 **总结表格**： | 特性 | `Collections.synchronizedList()` | `CopyOnWriteArrayList` | |--------------------------|--------------------------------------------------|------------------------------------------------| | **线程安全机制** | 方法级synchronized锁 | 写时复制（读无锁，写加锁） | | **读性能** | 中等（需要获取锁） | 非常高（无锁） | | **写性能** | 中等（只需要获取锁，无复制） | 低（需要复制整个数组） | | **内存占用** | 低 | 高（写操作时可能产生内存压力） | | **迭代器行为** | 快速失败（需要外部同步迭代） | 弱一致性（无需同步，但可能不是最新数据） | | **复合操作原子性** | 需要外部同步 | 内置原子方法（如`addIfAbsent()`） | | **适用场景** | 读写相对均衡，或写多读少 | 读多写少（如监听器列表、配置信息等） | **选择建议**： - 如果需要频繁读取而很少写入，选择`CopyOnWriteArrayList`。 - 如果读写操作相对均衡，或者写操作较多，选择`Collections.synchronizedList()`可能更合适。 - 如果需要在迭代过程中避免并发修改异常，且可以接受可能读取到稍旧的数据，则选择`CopyOnWriteArrayList`。 - 如果需要执行复合操作（如“检查再添加”），并且不想手动同步，则`CopyOnWriteArrayList`提供了内置的原子方法（如`addIfAbsent()`）[^4]。 **示例代码对比**： 使用`Collections.synchronizedList()`时，遍历需要手动同步： ```java List<String> syncList = Collections.synchronizedList(new ArrayList<>()); // 添加元素不需要额外同步（因为每个方法都同步） syncList.add("A"); syncList.add("B"); // 遍历时需要手动同步 synchronized (syncList) { for (String s : syncList) { System.out.println(s); } } ``` 使用`CopyOnWriteArrayList`时，遍历无需同步： ```java CopyOnWriteArrayList<String> cowList = new CopyOnWriteArrayList<>(); cowList.add("A"); cowList.add("B"); // 遍历无需同步（使用创建迭代器时的数组快照） for (String s : cowList) { System.out.println(s); } ``` **注意事项**： - 对于`CopyOnWriteArrayList`，在写操作频繁的场景下，由于反复复制数组，可能导致性能下降和内存占用增加。 - 对于`Collections.synchronizedList()`，在高并发场景下，锁竞争可能导致性能瓶颈。 通过以上对比，可以根据具体应用场景选择合适的线程安全列表实现。 --- §§相关问题§§ 1. `CopyOnWriteArrayList` 在写多读少场景下为何性能差？ 2. 如何保证 `Collections.synchronizedList()` 复合操作的线程安全？ 3. `CopyOnWriteArrayList` 的迭代器弱一致性具体指什么？ 4. 在哪些实际应用场景中优先选择 `CopyOnWriteArrayList`？</think>### Collections.synchronizedList() 与 CopyOnWriteArrayList 核心区别 #### 1. **线程安全机制** | **特性** | `Collections.synchronizedList()` | `CopyOnWriteArrayList` | |-------------------|-------------------------------------------------|---------------------------------------------| | **实现原理** | 方法级 `synchronized` 全局锁 | 写时复制 (Copy-On-Write) + `ReentrantLock` | | **锁粒度** | 整个列表对象锁 | 仅写操作加锁（读操作无锁） | | **锁类型** | 悲观锁 | 写操作为悲观锁，读操作为乐观锁 | | **典型代码** | ```synchronized(mutex) { list.add(e); }``` [^1] | ```lock.lock(); 复制数组; 修改; 替换引用``` [^4] | #### 2. **性能对比** | **场景** | `Collections.synchronizedList()` | `CopyOnWriteArrayList` | **原因分析** | |-------------------|----------------------------------|-------------------------------|-----------------------------------------------------------------------------| | **读操作** | 中等（需抢锁）[^1][^2] | **极高**（无锁直接访问）[^1] | 读操作无需复制数据或等待锁释放 | | **写操作** | **较高**（仅需抢锁）[^1][^2] | 极低（需复制整个数组）[^1][^4] | 每次写操作需复制新数组 ($O(n)$)，数据量大时性能急剧下降 | | **复合操作** | 需外部同步[^4] | 内置原子方法（如`addIfAbsent`）| `synchronizedList` 需手动同步检查-修改操作 | | **内存占用** | 低（仅包装原列表）[^2] | 高（写操作时双倍内存）[^2] | 写操作需复制整个数组 | #### 3. **迭代器行为** | **特性** | `Collections.synchronizedList()` | `CopyOnWriteArrayList` | |-------------------|-----------------------------------------|-------------------------------------| | **一致性** | 快速失败 (Fail-Fast) [^5] | 弱一致性 (Weakly Consistent) [^1][^4] | | **并发修改** | 抛出 `ConcurrentModificationException` | 使用迭代器创建时的数组快照 | | **同步要求** | 需手动同步整个迭代过程[^2][^4] | **无需额外同步** | | **示例代码** | ```synchronized(list) { for(...) }``` | 直接使用 `for-each` 循环 | #### 4. **适用场景** | **场景** | 推荐容器 | **原因** | |--------------------------|-----------------------------------|-------------------------------------------------------------------------| | **高频读 + 低频写** | `CopyOnWriteArrayList` [^1][^4] | 读操作无锁优势明显（如配置信息、监听器列表） | | **读写均衡/高频写** | `Collections.synchronizedList()` [^1] | 写操作无数组复制开销 | | **大型集合写操作** | `Collections.synchronizedList()` | 避免大数组复制的内存和CPU消耗 | | **需要原子复合操作** | `CopyOnWriteArrayList` [^4] | 内置 `addIfAbsent()` 等原子方法 | | **迭代频繁且怕异常** | `CopyOnWriteArrayList` | 迭代过程永不抛 `ConcurrentModificationException` | --- ### 关键问题解析 #### 1. **为什么写多读少时 `CopyOnWriteArrayList` 性能差？** - **数组复制开销**：每次写操作（`add/set/remove`）需复制整个数组，时间复杂度 $O(n)$ - **内存压力**：大集合修改时可能触发GC（如1GB数组修改需额外1GB内存） - **锁竞争**：虽然写操作用锁，但复制过程阻塞其他写操作[^1][^4] #### 2. **如何保证 `synchronizedList` 复合操作安全？** ```java List<String> list = Collections.synchronizedList(new ArrayList<>()); // 错误方式：非原子操作 if (!list.contains("key")) { list.add("key"); // 可能被其他线程打断 } // 正确方式：外部同步块 synchronized (list) { // 获取与内部相同的锁 if (!list.contains("key")) { list.add("key"); } } // 同步块结束释放锁[^4] ``` #### 3. **`CopyOnWriteArrayList` 迭代器弱一致性** - 迭代器创建时**固定当前数组引用**为快照 - 后续写操作修改的是**新复制的数组**，不影响快照 - 迭代器遍历的是**历史数据**，可能不包含最新修改[^1][^4] --- ### 总结对比表 | **维度** | `Collections.synchronizedList()` | `CopyOnWriteArrayList` | |------------------|---------------------------------------|---------------------------------------| | **线程安全机制** | 方法级 `synchronized` 全局锁 | 写时复制 + 桶锁 | | **读性能** | ⭐⭐ (需抢锁) | ⭐⭐⭐⭐⭐ (无锁) | | **写性能** | ⭐⭐⭐ (仅锁竞争) | ⭐ (数组复制开销) | | **内存效率** | ⭐⭐⭐⭐⭐ | ⭐⭐ (写时双倍内存) | | **迭代安全性** | 需手动同步 | 内置安全 | | **复合操作** | 需外部同步 | 内置原子方法 | | **最佳场景** | 写多读少/均衡 | 读多写少/要求无锁读 | > **经验法则**： > - 监听器列表（读多写少） → `CopyOnWriteArrayList` > - 高频更新的业务数据 → `Collections.synchronizedList()` 或 `ConcurrentHashMap` > - 需要安全迭代 → 优先选 `CopyOnWriteArrayList` 避免手动同步 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值