05、Java并发编程:集合的线程安全

本文是 Java 并发编程系列的第五篇。前面几篇我们聊过线程、锁、volatile、AQS 与线程池,本篇把视角落到日常开发使用频率最高的工具上:集合框架。为什么一个普通的
ArrayList、HashMap放到多线程环境下就会出事故?JDK 提供了哪些线程安全集合?Vector、Collections.synchronizedList、CopyOnWriteArrayList、ConcurrentHashMap之间到底怎么选?企业项目里这些容器又分别用在什么位置?本文从生产事故讲起,把线程安全集合的定义、演进、源码原理、代码实战、选型对比与高频面试题一次性讲透,读完可以直接上手。
文章目录
- 05、Java并发编程:集合的线程安全
-
- 一、痛点场景:这些线上事故,几乎都和集合有关
-
- [1.1 场景一:多线程并发 add,列表里的元素凭空消失](#1.1 场景一:多线程并发 add,列表里的元素凭空消失)
- [1.2 场景二:并发写 HashMap,数据被覆盖,历史版本还出现过链表成环](#1.2 场景二:并发写 HashMap,数据被覆盖,历史版本还出现过链表成环)
- [1.3 场景三:遍历集合的同时修改,抛出 ConcurrentModificationException](#1.3 场景三:遍历集合的同时修改,抛出 ConcurrentModificationException)
- [1.4 场景四:误用 Vector 兜底,接口在高并发下被全局锁拖垮](#1.4 场景四:误用 Vector 兜底,接口在高并发下被全局锁拖垮)
- [1.5 痛点归纳](#1.5 痛点归纳)
- 二、痛点的解决方案:三条解决思路与选型总览
- 三、是什么:线程安全集合到底是什么
-
- [3.1 专业解释](#3.1 专业解释)
- [3.2 Java 集合框架的安全与不安全清单](#3.2 Java 集合框架的安全与不安全清单)
- [3.3 大白话理解](#3.3 大白话理解)
- [3.4 生活案例](#3.4 生活案例)
- 四、为什么要用:普通集合在并发下到底坏在哪里
-
- [4.1 原子性:看似一行代码,背后是多步操作](#4.1 原子性:看似一行代码,背后是多步操作)
- [4.2 可见性:工作内存与主内存的可见性问题](#4.2 可见性:工作内存与主内存的可见性问题)
- [4.3 复合操作:contains 再 put 不是原子的](#4.3 复合操作:contains 再 put 不是原子的)
- [4.4 迭代与修改:fail-fast 机制](#4.4 迭代与修改:fail-fast 机制)
- 五、怎么演进过来的:从全表锁到细粒度锁与无锁算法
-
- [5.1 第一阶段:JDK 1.0 的 Vector 与 Hashtable](#5.1 第一阶段:JDK 1.0 的 Vector 与 Hashtable)
- [5.2 第二阶段:Collections 同步包装器](#5.2 第二阶段:Collections 同步包装器)
- [5.3 第三阶段:JDK 1.5 JUC 包,并发容器专业化](#5.3 第三阶段:JDK 1.5 JUC 包,并发容器专业化)
- [5.4 ConcurrentHashMap 的两代实现](#5.4 ConcurrentHashMap 的两代实现)
- [5.5 CopyOnWrite 的思想来源](#5.5 CopyOnWrite 的思想来源)
- 六、怎么用:企业项目代码实战
-
- [6.1 原子化 KV 缓存:ConcurrentHashMap](#6.1 原子化 KV 缓存:ConcurrentHashMap)
- [6.2 读多写少的列表:CopyOnWriteArrayList](#6.2 读多写少的列表:CopyOnWriteArrayList)
- [6.3 生产者消费者:BlockingQueue](#6.3 生产者消费者:BlockingQueue)
- [6.4 反面教材:复现普通集合的并发问题](#6.4 反面教材:复现普通集合的并发问题)
- [6.5 Spring 项目中的落地写法](#6.5 Spring 项目中的落地写法)
- 七、竞品对比:主流线程安全集合优劣势表格
-
- [7.1 List 维度对比](#7.1 List 维度对比)
- [7.2 Map 维度对比](#7.2 Map 维度对比)
- [7.3 Queue 维度对比](#7.3 Queue 维度对比)
- [7.4 选型决策要点](#7.4 选型决策要点)
- 八、三维度解析:专业解释、大白话、生活案例
-
- [8.1 ConcurrentHashMap](#8.1 ConcurrentHashMap)
- [8.2 CopyOnWriteArrayList](#8.2 CopyOnWriteArrayList)
- [8.3 BlockingQueue](#8.3 BlockingQueue)
- [8.4 Collections 同步包装器](#8.4 Collections 同步包装器)
- 九、常用场景与企业项目落地
-
- [9.1 本地缓存与会话存储](#9.1 本地缓存与会话存储)
- [9.2 监听器与观察者列表](#9.2 监听器与观察者列表)
- [9.3 异步任务与削峰填谷](#9.3 异步任务与削峰填谷)
- [9.4 计数器与原子统计](#9.4 计数器与原子统计)
- [9.5 有序并发数据](#9.5 有序并发数据)
- [9.6 配置与只读数据](#9.6 配置与只读数据)
- [9.7 落地检查清单](#9.7 落地检查清单)
- 十、面试官高频面试题
-
- [10.1 哪些集合是线程安全的,哪些不是?](#10.1 哪些集合是线程安全的,哪些不是?)
- [10.2 ArrayList 在并发环境下会出现什么问题?](#10.2 ArrayList 在并发环境下会出现什么问题?)
- [10.3 ConcurrentHashMap 在 JDK 1.7 和 1.8 的实现有什么区别?为什么 1.8 要改?](#10.3 ConcurrentHashMap 在 JDK 1.7 和 1.8 的实现有什么区别?为什么 1.8 要改?)
- [10.4 ConcurrentHashMap 为什么不允许 null key 和 null value?](#10.4 ConcurrentHashMap 为什么不允许 null key 和 null value?)
- [10.5 CopyOnWriteArrayList 的原理是什么?适合什么场景,不适合什么场景?](#10.5 CopyOnWriteArrayList 的原理是什么?适合什么场景,不适合什么场景?)
- [10.6 CopyOnWriteArrayList 和 Vector、synchronizedList 相比优劣势是什么?](#10.6 CopyOnWriteArrayList 和 Vector、synchronizedList 相比优劣势是什么?)
- [10.7 ConcurrentHashMap 的 size 是怎么统计的?](#10.7 ConcurrentHashMap 的 size 是怎么统计的?)
- [10.8 BlockingQueue 常见实现有哪些?生产者消费者模型怎么用?](#10.8 BlockingQueue 常见实现有哪些?生产者消费者模型怎么用?)
- [10.9 ConcurrentLinkedQueue 和 LinkedBlockingQueue 有什么区别?](#10.9 ConcurrentLinkedQueue 和 LinkedBlockingQueue 有什么区别?)
- [10.10 fail-fast 和 fail-safe(弱一致)迭代有什么区别?](#10.10 fail-fast 和 fail-safe(弱一致)迭代有什么区别?)
- [10.11 迭代线程安全集合时还需要手动加锁吗?](#10.11 迭代线程安全集合时还需要手动加锁吗?)
- [10.12 需要并发有序 Map 应该用什么?和 TreeMap 有什么区别?](#10.12 需要并发有序 Map 应该用什么?和 TreeMap 有什么区别?)
- 十一、总结
一、痛点场景:这些线上事故,几乎都和集合有关
很多初学者对"线程安全"的理解停留在锁和 synchronized 关键字上,认为只要方法里加了锁就万事大吉。但在真实的企业项目里,集合是被多个线程共享最频繁的数据结构,绝大多数并发事故的现场,都能看到一个被多线程同时读写的普通集合。下面四个场景来自常见的线上故障复盘,具备很强的代表性。
1.1 场景一:多线程并发 add,列表里的元素凭空消失
订单服务上线了一个异步汇总任务:10 个线程并发地把各自统计到的订单 ID 放进同一个 ArrayList,最后主线程统一落库。预期集合里应该有 10000 条数据,实际落库只有 9000 多条,偶尔还会抛出数组下标越界异常。
问题出在 ArrayList.add(E) 并不是一个原子操作。它内部至少包含三步:检查当前数组容量是否足够、把元素写入 elementData[size]、把 size 加一。两个线程同时执行时,可能都读到 size = 10,各自把元素写到下标 10 的位置,后写的覆盖先写的,于是一个元素被吞掉;如果刚好撞上扩容,旧数组和新数组的复制过程竞争,还可能出现 ArrayIndexOutOfBoundsException。
1.2 场景二:并发写 HashMap,数据被覆盖,历史版本还出现过链表成环
缓存模块用静态 HashMap 保存用户会话,多个业务线程同时 put。偶发出现两个不同 key 落到同一个桶后互相覆盖,读取到的 value 与写入时不一致。在 JDK 7 及更早版本中,并发扩容还可能让桶内链表反转成环形结构,导致 get 操作死循环,CPU 直接打满。JDK 8 改成尾插法后不再成环,但 HashMap 依然没有任何同步保护,并发写入仍然会丢数据、覆盖数据。
1.3 场景三:遍历集合的同时修改,抛出 ConcurrentModificationException
后台任务一边遍历 ArrayList 做筛选,另一个定时线程同时往里面 add 数据。遍历到一半直接抛出 java.util.ConcurrentModificationException。这是集合的 fail-fast(快速失败)机制:迭代器在遍历过程中检查 modCount(集合被修改的次数),发现它和迭代器初始化时记录的值不一致,就立刻抛异常终止遍历。这个机制本意是尽早暴露并发问题,但在多线程场景下,它让程序从"数据错误"升级成了"直接崩溃"。
1.4 场景四:误用 Vector 兜底,接口在高并发下被全局锁拖垮
开发知道 ArrayList 线程不安全,于是把所有共享列表换成了 Vector。上线后压测发现接口响应时间随着并发数上升急剧恶化,线程栈大量阻塞在 Vector 的 synchronized 方法上。原因是 Vector 的每个读写方法都加了同一把对象锁,读和写互斥、读和读也互斥,高并发下所有线程排队抢同一把锁,吞吐量被锁竞争严重拖低。

1.5 痛点归纳
把上面四个场景抽象一下,普通集合在多线程环境下的风险集中在四类:
- 原子性缺失:复合操作(检查容量、写入、更新 size)被线程切换打断,导致元素覆盖、丢失、越界。
- 可见性缺失:一个线程对集合内部数组的修改,其他线程不能保证立刻看到。
- 复合操作不安全 :
if (map.containsKey(k)) map.put(k, v)这类"先判断再写入"的组合动作,中间存在竞争窗口。 - 迭代与修改冲突:遍历过程中集合被修改,触发 fail-fast 异常;即使不抛异常,遍历结果也可能不完整。
二、痛点的解决方案:三条解决思路与选型总览
针对上述问题,JDK 与工程实践给出了三条思路,理解这三条思路,比记住具体类名更重要。
思路一:外部同步,给普通集合套一层锁。 不修改集合本身,而是在所有访问共享集合的代码位置加 synchronized,或者用 Collections.synchronizedList、Collections.synchronizedMap 把普通集合包装成同步集合。本质是一把全局锁保护整个集合,实现简单,但锁粒度粗,并发性能有限。
思路二:使用 JUC 并发容器。 java.util.concurrent 包下提供了专门为并发场景设计的集合:ConcurrentHashMap、CopyOnWriteArrayList、ConcurrentLinkedQueue、各种 BlockingQueue、ConcurrentSkipListMap 等。它们通过细粒度锁、CAS 无锁算法、写时复制、读写分离等手段,在保证线程安全的同时尽量提升并发度,是企业项目中的首选。
思路三:不可变容器规避共享可变。 如果数据初始化后不再修改,可以用 Collections.unmodifiableList、Map.of、List.of 返回不可变视图或不可变集合,从根本上消除并发修改的可能。不可变对象天然线程安全,是高并发设计中最省心的方案。

选型的第一原则是先判断业务特征:是 Map、List 还是 Queue;读多还是写多;是否要求有序;是否需要阻塞等待。不同业务特征对应不同容器,后面第七节会给出完整的对比表格。
三、是什么:线程安全集合到底是什么
3.1 专业解释
线程安全集合,是指在多个线程并发访问时,不需要调用方额外加同步措施,集合自身就能保证内部状态始终一致、不会出现数据丢失、覆盖、损坏或非法状态的集合实现。判断一个集合是否线程安全,要看它是否同时满足:
- 原子性:每个公开方法的内部复合步骤作为整体执行,不会被其他线程的操作穿插打断。
- 可见性:一个线程对集合结构或元素的修改,对后续访问的线程可见。
- 有序性:必要时通过内存屏障或 volatile 字段禁止指令重排,保证观察到的操作顺序符合预期。
- 迭代安全:迭代器在并发修改下的行为有明确约定,要么基于快照遍历,要么弱一致遍历,而不是抛出未预期的异常。
3.2 Java 集合框架的安全与不安全清单
下面这张清单是日常开发必须背下来的基础事实。
非线程安全(单线程使用,或外部自行加锁):
- List:
ArrayList、LinkedList - Map:
HashMap、LinkedHashMap、TreeMap - Set:
HashSet、LinkedHashSet、TreeSet - Queue/Deque:
ArrayDeque以及其他非线程安全的普通队列实现
早期线程安全(粗粒度 synchronized,性能一般):
- List:
Vector、Stack(继承自 Vector) - Map:
Hashtable - 字符串缓冲区:
StringBuffer(属于可变字符序列,常被放在一起讨论)
同步包装器(全局锁包装普通集合):
Collections.synchronizedList(List)Collections.synchronizedMap(Map)Collections.synchronizedSet(Set)Collections.synchronizedSortedMap、Collections.synchronizedSortedSet
JUC 并发容器(细粒度锁或无锁,高并发首选):
- Map:
ConcurrentHashMap、ConcurrentSkipListMap - List:
CopyOnWriteArrayList - Set:
CopyOnWriteArraySet - Queue:
ConcurrentLinkedQueue、ConcurrentLinkedDeque、ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue、DelayQueue、SynchronousQueue、LinkedTransferQueue
3.3 大白话理解
普通集合就像一个没有管理员的公共白板,谁都可以上去写,两个人同时写就会互相涂改。线程安全集合相当于给白板配了规则:要么每次只允许一个人写(加锁),要么大家各拿一份副本写完再统一替换(写时复制),要么把白板分成多个格子,不同格子之间互不影响(分段锁、桶级锁)。无论哪种规则,最终保证的结果是:白板上的内容永远是完整、正确、看得懂的。
3.4 生活案例
想象一个共享的外卖订单登记簿。没有规则时,十个骑手同时在本子上记订单,一页纸被几个人同时写,字迹叠在一起,最后谁也看不清。线程安全集合就是这本登记簿的三种管理方式:Vector 是配一个管理员,谁来都要排队等管理员盖章;ConcurrentHashMap 是把本子分成几十页,不同页由不同管理员管,互不排队;CopyOnWriteArrayList 是平时大家只看原本子,需要改的时候先复印一份新本子,在副本上改完再把新本子换上去,看的人始终不会被打断。
四、为什么要用:普通集合在并发下到底坏在哪里
4.1 原子性:看似一行代码,背后是多步操作
以 ArrayList.add 为例,JDK 8 源码核心逻辑如下(简化表达):
java
// ArrayList.add 的简化源码,展示复合操作
public boolean add(E e) {
ensureCapacityInternal(size + 1); // 第一步:检查并扩容
elementData[size] = e; // 第二步:写入数组
size++; // 第三步:元素数量加一
return true;
}
这三步之间没有任何同步。线程 A 执行完第一步、第二步,在 size++ 之前被切换走;线程 B 同样读到旧的 size,写入同一个下标。两个元素只留下一个,另一个被覆盖。这就是 1.1 场景中元素丢失的根因。
4.2 可见性:工作内存与主内存的可见性问题
普通集合内部数组(elementData)和 size 都没有用 volatile 修饰。线程写入后的值可能停留在 CPU 工作内存,没有及时刷回主内存,其他线程读到的仍是旧值。结果就是:主线程认为集合里只有少量元素,而工作线程明明已经写入成功。
4.3 复合操作:contains 再 put 不是原子的
下面这段代码在单线程下没问题,在多线程下仍然不安全:
java
// 错误示范:check-then-act 复合操作存在竞争窗口
if (!map.containsKey(key)) {
map.put(key, value);
}
两个线程可能同时判断 containsKey 为 false,然后都执行 put;如果是初始化统计值的场景,还会出现计数被重置。正确做法是使用并发容器提供的原子方法,例如 ConcurrentHashMap.putIfAbsent:
java
// 正确:putIfAbsent 是原子操作,不存在判断与写入之间的窗口
V old = concurrentMap.putIfAbsent(key, value);
4.4 迭代与修改:fail-fast 机制
集合内部维护一个 modCount 字段,记录结构修改次数。迭代器创建时把它快照为 expectedModCount;每次迭代检查两者是否相等,不等就抛出 ConcurrentModificationException。这个机制在单线程下帮你尽早发现"遍历中删除元素"的低级错误,但在多线程下,另一个线程的合法修改也会触发它,导致程序崩溃。JUC 并发容器则走另一条路线:要么基于不可变快照遍历(CopyOnWrite),要么采用弱一致(weakly consistent)迭代,遍历过程中允许并发修改,迭代器不会抛异常,但不保证反映迭代开始之后的所有变更。
五、怎么演进过来的:从全表锁到细粒度锁与无锁算法
线程安全集合的演进,主线就是一条:锁粒度不断变细,阻塞范围不断缩小,读操作尽量不加锁。理解这条主线,源码细节就有了抓手。

5.1 第一阶段:JDK 1.0 的 Vector 与 Hashtable
Vector 和 Hashtable 是 JDK 1.0 就存在的线程安全容器。实现方式非常直接:每个公开方法都加上 synchronized,锁住整个集合对象。任何一个线程在读或写时,其他所有线程都必须等待。优点是实现简单、语义明确;缺点是锁粒度是整个集合,读读之间也互斥,高并发下吞吐量低。这也是现代代码中不推荐优先使用 Vector、Hashtable 的主要原因。
5.2 第二阶段:Collections 同步包装器
JDK 1.2 推出集合框架后,提供了 Collections.synchronizedList 等静态工厂方法,把任意普通集合包装成同步版本。返回的代理类在每个方法上 synchronized (mutex),原理和 Vector 类似:一把全局锁保护所有方法。它解决了"普通集合怎么变成线程安全"的通用性问题,但本质仍是粗粒度全局锁,性能瓶颈没有改变。另外要特别注意:包装集合后的迭代器不是自动同步的,遍历必须手动放进 synchronized 代码块:
java
List<E> list = Collections.synchronizedList(new ArrayList<>());
// 迭代时必须手动加锁,否则仍然可能抛 ConcurrentModificationException
synchronized (list) {
for (E e : list) {
process(e);
}
}
5.3 第三阶段:JDK 1.5 JUC 包,并发容器专业化
JDK 1.5 引入 java.util.concurrent 包,线程安全集合脱离了"一把大锁"的思路,针对不同数据结构和业务特征设计专门实现:
ConcurrentHashMap:Map 场景,桶级锁加 CAS。CopyOnWriteArrayList:List 场景,读多写少,读无锁、写复制。ConcurrentLinkedQueue:队列场景,CAS 无锁算法。BlockingQueue家族:生产者消费者场景,阻塞式入队出队。
5.4 ConcurrentHashMap 的两代实现
ConcurrentHashMap 是并发集合中被讨论最多的类,它自身也经历了两代实现。
JDK 1.7:Segment 分段锁。 整个哈希表被切分成若干个 Segment(默认 16 段),每个 Segment 是一把独立的 ReentrantLock,保护段内的一个小哈希表。不同段上的线程可以并发写入,锁粒度从"整个表"细化到"段"。缺点是段数量在构造时确定,段内仍是完整哈希表;一次定位可能需要两次哈希;实现结构相对笨重。
JDK 1.8:Node + CAS + synchronized。 取消了 Segment 结构,底层是 Node 数组加链表或红黑树。写入空桶时用 CAS 直接插入;桶非空时,synchronized 锁住桶的头节点,不同桶之间互不阻塞。读取操作基于 volatile 变量,大多数场景不加锁。链表长度超过阈值 8 且数组长度达到 64 时转红黑树,保证最坏查找复杂度为 O(log n)。锁粒度从段细化到单个桶,并发度进一步提升。
5.5 CopyOnWrite 的思想来源
写时复制(Copy-On-Write)的思路与读写锁一脉相承:读读不互斥,读写不互斥,只有写写互斥。它比读写锁更激进:读操作完全不加锁,写操作时复制一份新数组,在副本上完成修改,再把内部引用指向新数组。旧数组留给正在遍历的读线程使用,因此读线程拿到的始终是一份稳定快照。代价是每次写入都要复制整个底层数组,所以只适合读远多于写的场景。
六、怎么用:企业项目代码实战
本节给出可以直接搬到项目里的代码模板。Java 是主线实现;涉及与其他语言对照时,同时给出 Python 版本,方便跨语言理解同一套并发思路。所有代码块均标注语言标识。
6.1 原子化 KV 缓存:ConcurrentHashMap
Java 版本:
java
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
public class TokenCache {
private static final ConcurrentMap<String, UserSession> SESSION_CACHE = new ConcurrentHashMap<>();
public UserSession getOrCreate(String token) {
// putIfAbsent 是原子操作,等价于线程安全的 check-then-act
return SESSION_CACHE.putIfAbsent(token, new UserSession(token));
}
public void refresh(String token, long expireAt) {
// compute 原子地完成读取、计算、写回,适合需要基于旧值更新的场景
SESSION_CACHE.compute(token, (k, old) -> {
if (old == null) {
return new UserSession(k, expireAt);
}
old.setExpireAt(expireAt);
return old;
});
}
public void invalidate(String token) {
SESSION_CACHE.remove(token);
}
static class UserSession {
private final String token;
private volatile long expireAt;
UserSession(String token) {
this.token = token;
this.expireAt = System.currentTimeMillis() + 30 * 60 * 1000L;
}
UserSession(String token, long expireAt) {
this.token = token;
this.expireAt = expireAt;
}
void setExpireAt(long expireAt) {
this.expireAt = expireAt;
}
}
}
常用原子方法说明:
putIfAbsent(key, value):key 不存在时放入并返回 null,存在则返回旧值,整步原子完成。compute(key, remappingFunction):原子地基于旧值计算并写回,适合计数、状态更新。computeIfAbsent、computeIfPresent:带条件的原子更新。merge(key, value, remappingFunction):合并旧值与新值,统计场景常用。
Python 对照版本: Python 标准库没有内置并发哈希表,工程上通常用 dict 加一把锁保护,语义对应 Collections.synchronizedMap;高并发读多写少场景可在锁内做快照复制。下面是与上面 Java 示例思路对应的 Python 实现:
python
import threading
from dataclasses import dataclass
from datetime import datetime, timedelta
@dataclass
class UserSession:
token: str
expire_at: float
class TokenCache:
def __init__(self) -> None:
self._cache: dict[str, UserSession] = {}
# 与 synchronizedMap 对应:一把互斥锁保护整个字典
self._lock = threading.Lock()
def get_or_create(self, token: str) -> UserSession:
with self._lock:
if token not in self._cache:
self._cache[token] = UserSession(
token,
(datetime.now() + timedelta(minutes=30)).timestamp(),
)
return self._cache[token]
def refresh(self, token: str, expire_at: float) -> None:
with self._lock:
if token in self._cache:
self._cache[token].expire_at = expire_at
else:
self._cache[token] = UserSession(token, expire_at)
def invalidate(self, token: str) -> None:
with self._lock:
self._cache.pop(token, None)
注意:Python 中 dict 的单次 get、put 在 GIL 保护下表现为原子字节码操作,但"先判断再写入"这类复合操作仍然需要锁,和 Java 的原则完全一致。
6.2 读多写少的列表:CopyOnWriteArrayList
典型场景:事件监听器列表、白名单配置列表、路由规则列表。这些数据平时被大量线程读取,只在配置变更或注册监听器时才少量写入。
Java 版本:
java
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
public class EventNotifier {
// 监听器注册不频繁,通知频繁,典型的读多写少
private final List<EventListener> listeners = new CopyOnWriteArrayList<>();
public void register(EventListener listener) {
listeners.addIfAbsent(listener);
}
public void unregister(EventListener listener) {
listeners.remove(listener);
}
public void notifyAll(Event event) {
// 遍历基于不可变快照,不需要加锁,也不会抛 ConcurrentModificationException
for (EventListener listener : listeners) {
listener.onEvent(event);
}
}
public interface EventListener {
void onEvent(Event event);
}
public static class Event {
private final String type;
private final Object payload;
public Event(String type, Object payload) {
this.type = type;
this.payload = payload;
}
public String getType() {
return type;
}
public Object getPayload() {
return payload;
}
}
}
Python 对照版本: 用互斥锁保护写操作,写时复制整份列表,读操作直接引用当前快照,复刻 Copy-On-Write 语义:
python
import threading
class CopyOnWriteList:
def __init__(self) -> None:
self._lock = threading.Lock()
self._items: list = []
def add_if_absent(self, item) -> None:
with self._lock:
if item not in self._items:
# 写时复制:在副本上修改,再替换整体引用
new_items = list(self._items)
new_items.append(item)
self._items = new_items
def remove(self, item) -> None:
with self._lock:
if item in self._items:
new_items = list(self._items)
new_items.remove(item)
self._items = new_items
def snapshot(self) -> list:
# 读操作不加锁,返回当前内部列表的引用;遍历期间不会被写操作打断
return list(self._items)
6.3 生产者消费者:BlockingQueue
线程池内部任务队列、异步消息处理、削峰填谷都依赖阻塞队列。队列满时生产者阻塞等待,队列空时消费者阻塞等待,由队列协调两侧节奏。
Java 版本:
java
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
public class OrderQueue {
private final BlockingQueue<String> queue = new ArrayBlockingQueue<>(100);
// 生产者:队列满则阻塞,直到有空位
public void produce(String orderId) throws InterruptedException {
queue.put(orderId);
}
// 消费者:队列空则阻塞,直到有新元素;带超时版本避免无限等待
public String consume(long timeout, TimeUnit unit) throws InterruptedException {
return queue.poll(timeout, unit);
}
public int size() {
return queue.size();
}
}
配套的生产者、消费者线程模板:
java
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class OrderProcessingDemo {
public static void main(String[] args) throws InterruptedException {
OrderQueue orderQueue = new OrderQueue();
ExecutorService pool = Executors.newFixedThreadPool(4);
// 生产者线程:模拟订单写入
Runnable producer = () -> {
for (int i = 0; i < 20; i++) {
try {
orderQueue.produce("ORDER-" + i);
System.out.println("produced: ORDER-" + i);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
};
// 消费者线程:模拟订单处理
Runnable consumer = () -> {
while (!Thread.currentThread().isInterrupted()) {
try {
String orderId = orderQueue.consume(1, java.util.concurrent.TimeUnit.SECONDS);
if (orderId != null) {
System.out.println("consumed: " + orderId);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
};
pool.execute(producer);
for (int i = 0; i < 3; i++) {
pool.execute(consumer);
}
pool.shutdown();
}
}
Python 对照版本: queue.Queue 就是线程安全的阻塞队列,语义对应 BlockingQueue:
python
import queue
import threading
import time
class OrderQueue:
def __init__(self, capacity: int = 100) -> None:
self._queue: queue.Queue[str] = queue.Queue(maxsize=capacity)
def produce(self, order_id: str) -> None:
# 队列满时阻塞,对应 put
self._queue.put(order_id)
def consume(self, timeout: float = 1.0):
try:
return self._queue.get(timeout=timeout)
except queue.Empty:
return None
def producer(q: OrderQueue) -> None:
for i in range(20):
q.produce(f"ORDER-{i}")
print(f"produced: ORDER-{i}")
time.sleep(0.05)
def consumer(q: OrderQueue) -> None:
while True:
order_id = q.consume()
if order_id is not None:
print(f"consumed: {order_id}")
if __name__ == "__main__":
order_queue = OrderQueue()
threading.Thread(target=producer, args=(order_queue,)).start()
for _ in range(3):
threading.Thread(target=consumer, args=(order_queue,)).start()
6.4 反面教材:复现普通集合的并发问题
下面这段代码用于在本地复现事故,帮助理解为什么不能共享 ArrayList:
java
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
public class UnsafeArrayListDemo {
public static void main(String[] args) throws InterruptedException {
List<Integer> list = new ArrayList<>();
int threadCount = 10;
int perThread = 1000;
CountDownLatch latch = new CountDownLatch(threadCount);
for (int t = 0; t < threadCount; t++) {
new Thread(() -> {
try {
for (int i = 0; i < perThread; i++) {
list.add(i);
}
} finally {
latch.countDown();
}
}).start();
}
latch.await();
// 预期 10000,实际通常小于该值,偶发抛 ArrayIndexOutOfBoundsException
System.out.println("expected = " + threadCount * perThread + ", actual = " + list.size());
}
}
把 new ArrayList<>() 换成 new CopyOnWriteArrayList<>(),元素数量就稳定正确;换成 Collections.synchronizedList(new ArrayList<>()) 同样安全,但高并发下性能弱于 JUC 容器。
6.5 Spring 项目中的落地写法
在 Spring 业务服务中,共享集合通常声明为 static final 的并发容器字段。配置示例(YAML):
yaml
app:
cache:
session-prefix: SESSION
max-size: 10000
notify:
listener-initial-capacity: 16
order:
queue-capacity: 200
consumer-pool-size: 4
对应的服务类写法:
java
import org.springframework.stereotype.Service;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.CopyOnWriteArrayList;
@Service
public class OrderNotifyService {
private final ConcurrentHashMap<String, Long> sessionExpireMap = new ConcurrentHashMap<>();
private final CopyOnWriteArrayList<OrderListener> listeners = new CopyOnWriteArrayList<>();
private final BlockingQueue<String> orderQueue;
public OrderNotifyService(/* @Value 注入容量参数省略 */ int queueCapacity) {
this.orderQueue = new ArrayBlockingQueue<>(queueCapacity);
}
public void registerListener(OrderListener listener) {
listeners.addIfAbsent(listener);
}
public void submitOrder(String orderId) throws InterruptedException {
orderQueue.put(orderId);
}
private void dispatch(String orderId) {
for (OrderListener listener : listeners) {
listener.onOrder(orderId);
}
}
public interface OrderListener {
void onOrder(String orderId);
}
}
七、竞品对比:主流线程安全集合优劣势表格
7.1 List 维度对比
| 集合类 | 线程安全实现 | 读性能 | 写性能 | 迭代行为 | 适用场景 | 主要劣势 |
|---|---|---|---|---|---|---|
ArrayList |
不安全 | 高 | 高 | fail-fast,抛异常 | 单线程局部列表 | 多线程共享会丢数据、抛异常 |
Vector |
每个方法 synchronized,全局对象锁 | 低,读也互斥 | 低 | 迭代需手动加锁 | 遗留系统维护 | 锁粒度粗,并发性能差 |
Collections.synchronizedList |
代理方法 synchronized,全局锁 | 低 | 低 | 迭代必须手动加锁 | 小容量、低并发的通用包装 | 同样粗粒度;迭代容易漏加锁 |
CopyOnWriteArrayList |
写时复制,写操作加锁,读无锁 | 极高 | 低,每次写复制整个数组 | 基于不可变快照,永不抛 CME | 读远多于写:监听器、白名单、配置规则 | 写频繁或列表很大时内存与复制开销高;弱一致,读不到最新写入 |
7.2 Map 维度对比
| 集合类 | 线程安全实现 | 并发度 | 是否允许 null | 有序性 | 适用场景 | 主要劣势 |
|---|---|---|---|---|---|---|
HashMap |
不安全 | 无 | 允许 key/value 为 null | 无序(JDK8 链表+红黑树) | 单线程缓存、局部数据 | 并发写入丢数据、覆盖 |
Hashtable |
方法 synchronized,全局锁 | 低 | 不允许 null | 无序 | 遗留系统 | 全局锁;设计陈旧 |
Collections.synchronizedMap |
代理全局锁 | 低 | 跟随被包装 Map | 跟随被包装 Map | 低并发通用包装 | 粗粒度锁;迭代需手动加锁 |
ConcurrentHashMap |
CAS + synchronized 桶头锁,volatile 读 | 高,不同桶可并发写 | 不允许 null key/value | 无序 | 高并发 KV 缓存、计数器、会话表 | 不保证全局有序;迭代弱一致;不允许 null |
ConcurrentSkipListMap |
跳表结构,CAS 局部修改 | 高 | 不允许 null | 按 key 自然序或 Comparator 有序 | 需要并发有序 Map:排行榜、区间查询 | 插入删除略慢于哈希表;空间开销略大 |
7.3 Queue 维度对比
| 队列实现 | 阻塞/非阻塞 | 底层结构 | 有界性 | 锁策略 | 典型场景 |
|---|---|---|---|---|---|
ConcurrentLinkedQueue |
非阻塞 | 单向链表 | 无界 | CAS 无锁 | 高并发消息传递,对性能要求极高 |
ConcurrentLinkedDeque |
非阻塞 | 双向链表 | 无界 | CAS 无锁 | 双端并发队列 |
ArrayBlockingQueue |
阻塞 | 数组 | 必须指定容量 | 单把 ReentrantLock,读写共用 | 有界缓冲,资源可控 |
LinkedBlockingQueue |
阻塞 | 单向链表 | 可指定容量,默认无界(Integer.MAX_VALUE) | putLock 与 takeLock 两把锁 | 线程池任务队列,吞吐量较高 |
PriorityBlockingQueue |
阻塞 | 堆(数组) | 无界,可指定初始容量 | 单把 ReentrantLock | 优先级任务调度 |
DelayQueue |
阻塞 | 堆,元素带延时 | 无界 | 单把 ReentrantLock | 延时订单、过期会话、定时任务 |
SynchronousQueue |
阻塞 | 不存储元素 | 容量为 0 | CAS + 等待队列 | 直接移交,线程池 CachedThreadPool 使用 |
LinkedTransferQueue |
阻塞,可尝试移交 | 链表 | 无界 | CAS | 高性能生产者消费者,JDK7 新增 |
7.4 选型决策要点
- Map 场景默认选
ConcurrentHashMap;需要按 key 有序遍历或区间查找时选ConcurrentSkipListMap。 - List 场景:读多写少选
CopyOnWriteArrayList;写多读少或列表很大,优先考虑外部锁保护普通ArrayList,或使用Collections.synchronizedList并正确处理迭代加锁。 - Queue 场景:生产者消费者用
BlockingQueue;要求有界缓冲选ArrayBlockingQueue;追求高吞吐选LinkedBlockingQueue;纯无锁传递选ConcurrentLinkedQueue;延时任务选DelayQueue。 - 数据初始化后不再变化,优先用
List.of、Map.of或Collections.unmodifiableXxx,从根上消除并发问题。
八、三维度解析:专业解释、大白话、生活案例
8.1 ConcurrentHashMap
专业解释: 基于哈希表的并发 Map。JDK 1.8 底层为 Node<K,V>[] 数组,桶内链表长度达到 8 且数组长度达到 64 时转为红黑树。空桶插入使用 CAS;桶非空时 synchronized 锁定桶头节点;value 与链表指针使用 volatile 保证可见性。size 通过分段计数(类似 LongAdder 的 CounterCell 思路)降低计数竞争。迭代器为弱一致,不反映迭代开始之后的所有变更,也不会抛出 ConcurrentModificationException。
大白话: 它把大哈希表切成很多个小格子,两个人改不同格子不用排队;改同一个格子才短暂等一下;看数据的时候不需要锁,直接读。和 HashMap 的用法几乎一样,但天生适合多线程共享。
生活案例: 大型停车场,入口分成几十个车位区。管理员只在同一个车位区有人停车时维持秩序,不同区域的车辆互不干扰;找空位的人直接走进去看,不需要等管理员带路。
8.2 CopyOnWriteArrayList
专业解释: 线程安全的 List,底层数组由 volatile 引用持有。所有写操作(add、remove、set)在显式锁保护下复制一份新数组,在副本上完成修改,再把内部引用原子指向新数组。读操作与迭代器直接读取当前数组引用,不加锁,迭代基于快照进行,因此不会抛 fail-fast 异常。代价是写操作 O(n) 复制,且读线程可能读到旧版本数据(弱一致)。
大白话: 平时大家随便看,谁都不用排队;需要改的时候,先复印一份新名单,在复印件上改好,再把原件换成新复印件。老读者手里的旧名单不受影响。如果每天改名单很多次,复印成本就吃不消。
生活案例: 餐厅的顾客留言簿。绝大多数时间服务员只翻阅留言簿(读);遇到需要登记新留言时,前台先把整本复印一份,在副本上写完再换上新本,避免顾客翻阅时被涂改打断。但如果每分钟都有人留言,反复复印整本本子就非常低效。
8.3 BlockingQueue
专业解释: 继承自 Queue 的阻塞队列接口,提供两组方法:put/take 在队列满或空时阻塞等待;offer(e, timeout, unit)/poll(timeout, unit) 带超时的阻塞版本。内部通过锁与等待条件(Condition)协调生产者与消费者。它是线程池任务调度与生产者消费者模式的标准数据结构,解耦生产与消费的速度差异。
大白话: 一个带容量的传送传送带。放货的人看到传送带满了就停下等,拿货的人看到空了就停下等,队列自动协调两边节奏,不需要调用方自己写等待和唤醒逻辑。
生活案例: 奶茶店取餐台。吧台做好一杯放一杯,台子满了做餐员就等一下;顾客看到空台子就稍等,出餐和取餐通过取餐台自然配合,不会出现餐品堆放无处安放。
8.4 Collections 同步包装器
专业解释: 静态工厂方法返回委托代理类,所有方法委托给被包装集合,并在方法上 synchronized 互斥锁。迭代器未做同步包装,调用方必须在持有集合锁的代码块内遍历。语义与早期 Vector 类似,但可以把任意 List/Map/Set 包装成同步版本。
大白话: 给普通集合套一层"排队外套",所有操作都要先拿到外套钥匙才能动手。用法和原集合一样,但钥匙只有一把,所有人轮流用。
生活案例: 公共工具箱本身没人管,配一把挂锁和一位值班员,谁要用工具都先找值班员登记开门。安全是安全了,但十个人排队等一把钥匙,高峰期很慢。
九、常用场景与企业项目落地

9.1 本地缓存与会话存储
用户会话、配置项、接口结果缓存等 KV 数据,多线程读写,选 ConcurrentHashMap。需要过期淘汰时,配合定时清理或外部缓存组件(如 Caffeine、Redis)。注意 ConcurrentHashMap 不允许 null,避免把 null value 当作"不存在"写入。
9.2 监听器与观察者列表
事件监听器、插件钩子、告警规则列表,注册与注销频率低,触发通知频率高,选 CopyOnWriteArrayList。通知遍历不需要加锁,也不用担心遍历过程中新增监听器导致并发修改异常。
9.3 异步任务与削峰填谷
订单异步处理、日志收集、通知推送等生产者消费者场景,用 BlockingQueue 解耦生产与消费。流量高峰时队列缓冲请求,消费者按自身能力平稳处理,防止下游被瞬间打垮。线程池的任务队列本身就是 BlockingQueue 的典型应用。
9.4 计数器与原子统计
并发计数优先考虑 LongAdder;如果计数需要和业务 key 绑定,用 ConcurrentHashMap 配合 compute 或 merge 完成原子累加,避免"读旧值加一再写回"的竞争窗口。
9.5 有序并发数据
需要并发访问且保持 key 有序的场景(如区间排行榜、按时间排序的会话表),用 ConcurrentSkipListMap;对应的有序集合需求用 ConcurrentSkipListSet。不要在并发场景下共享 TreeMap、TreeSet。
9.6 配置与只读数据
初始化完成后不再修改的共享数据,使用 Collections.unmodifiableList、Map.of 返回不可变视图。既防止业务代码误写,也天然线程安全,是多线程设计中成本最低的安全方案。
9.7 落地检查清单
团队 Code Review 中遇到共享集合时,逐项核对:
- 集合是否被多个线程同时读写?是则不能使用普通
ArrayList、HashMap。 - 读多还是写多?读多写少考虑
CopyOnWriteArrayList;读写均衡考虑 JUC 并发容器。 - 是否需要有序?需要则选跳表实现的并发容器。
- 迭代
synchronizedList、synchronizedMap时,是否在 synchronized 代码块内? - 是否存在 check-then-act 复合操作?优先使用容器提供的原子方法。
- 队列是否需要有界?无界队列在消费滞后时可能耗尽内存。
- 数据是否真的需要共享?可以改成线程封闭(每个线程一份)或不可变对象,就不必上并发容器。
十、面试官高频面试题
10.1 哪些集合是线程安全的,哪些不是?
答: 不安全的有 ArrayList、LinkedList、HashMap、LinkedHashMap、TreeMap、HashSet、TreeSet、ArrayDeque。早期安全的有 Vector、Hashtable、Stack。JUC 并发容器有 ConcurrentHashMap、ConcurrentSkipListMap、CopyOnWriteArrayList、CopyOnWriteArraySet、ConcurrentLinkedQueue、各种 BlockingQueue。另外 Collections.synchronizedXxx 包装器可以把普通集合变成同步版本。
10.2 ArrayList 在并发环境下会出现什么问题?
答: 元素丢失或覆盖(add 的容量检查、写入、size 自增非原子);偶发 ArrayIndexOutOfBoundsException(扩容竞争);遍历过程中被其他线程修改会抛 ConcurrentModificationException。高并发下应改用 CopyOnWriteArrayList(读多写少)或外部加锁保护。
10.3 ConcurrentHashMap 在 JDK 1.7 和 1.8 的实现有什么区别?为什么 1.8 要改?
答: 1.7 采用 Segment 分段锁,默认 16 段,每段一把 ReentrantLock,结构为 Segment 数组加 HashEntry 数组加链表。1.8 取消 Segment,改为 Node 数组加链表/红黑树,空桶用 CAS 插入,非空桶用 synchronized 锁桶头节点。改动原因:分段锁粒度仍偏粗,段数量构造时固定;桶头锁粒度更细,不同桶并发度更高;synchronized 在 JDK 6 后经过锁升级优化,性能与可重入锁接近;链表过长时转红黑树,保证最坏 O(log n) 查找。
10.4 ConcurrentHashMap 为什么不允许 null key 和 null value?
答: 主要是为了消除歧义。在并发场景下,get(key) 返回 null 既可能表示 key 不存在,也可能表示 value 被显式存成 null;单线程下可以用 containsKey 二次判断,但并发下 containsKey 与 get 之间状态可能变化,二次判断结果不可靠。Doug Lea 的设计选择是直接禁止 null,避免这种二义性。HashMap 允许 null,是因为它只在单线程或外部同步场景下使用。
10.5 CopyOnWriteArrayList 的原理是什么?适合什么场景,不适合什么场景?
答: 写时复制:写操作加锁复制底层数组,在副本上修改后整体替换内部引用;读操作与迭代无锁,基于快照遍历,不抛并发修改异常。适合读远多于写、列表体量不大的场景:监听器列表、白名单、配置规则。不适合写频繁或列表很大的场景,因为每次写入都 O(n) 复制数组,内存抖动与复制开销明显;另外它是弱一致的,读线程可能暂时看不到最新写入。
10.6 CopyOnWriteArrayList 和 Vector、synchronizedList 相比优劣势是什么?
答: Vector 和 synchronizedList 用全局锁,读操作也互斥;CopyOnWriteArrayList 读无锁,读性能远高于前两者,迭代永不抛 CME。代价是写操作复制整个数组,写性能低、内存占用高;前两者写操作原地修改,写性能更好。选型看读写比例:读多写少选 COW,写多选全局锁方案或外部锁保护普通 ArrayList。
10.7 ConcurrentHashMap 的 size 是怎么统计的?
答: JDK 1.8 不使用单一全局计数器(高竞争下会成为热点),而是采用类似 LongAdder 的分段计数思想:基础计数加多个 CounterCell,分散竞争;size() 时汇总基础值与所有 CounterCell。这样不同线程的增量更新分散到不同单元,降低锁与 CAS 竞争。
10.8 BlockingQueue 常见实现有哪些?生产者消费者模型怎么用?
答: 常见实现:ArrayBlockingQueue(有界数组,单锁)、LinkedBlockingQueue(链表,两把锁,吞吐高)、PriorityBlockingQueue(优先级无界)、DelayQueue(延时)、SynchronousQueue(不存储元素,直接移交)、ConcurrentLinkedQueue(非阻塞 CAS)。生产者调用 put,队列满则阻塞;消费者调用 take,队列空则阻塞。队列作为中间缓冲解耦两侧,线程池内部任务队列就是 BlockingQueue。
10.9 ConcurrentLinkedQueue 和 LinkedBlockingQueue 有什么区别?
答: ConcurrentLinkedQueue 是非阻塞无锁队列,基于 CAS 操作链表节点,没有锁与等待条件,吞吐量高,但入队出队不会阻塞,调用方需要自行处理空队列重试。LinkedBlockingQueue 是阻塞队列,内部 putLock 与 takeLock 两把锁,队列满时生产者阻塞、空时消费者阻塞,天然适配生产者消费者模型。追求极致性能且自行处理重试选前者;需要阻塞协调选后者。
10.10 fail-fast 和 fail-safe(弱一致)迭代有什么区别?
答: fail-fast 以 ArrayList、HashMap 为代表,迭代器通过 modCount 检查结构是否被修改,发现不一致立即抛 ConcurrentModificationException。fail-safe/弱一致以 CopyOnWriteArrayList、ConcurrentHashMap 为代表,迭代基于快照或遍历当前并发修改的数据,不抛异常;迭代过程中允许并发修改,但不保证反映迭代开始后的全部变更。fail-fast 是尽早暴露问题的保护机制,不等于线程安全。
10.11 迭代线程安全集合时还需要手动加锁吗?
答: 分容器看。CopyOnWriteArrayList、ConcurrentHashMap、ConcurrentLinkedQueue 的迭代器本身设计为并发安全,遍历不需要额外加锁。Collections.synchronizedList、Collections.synchronizedMap 的迭代器没有被代理同步保护,必须把遍历放进 synchronized (集合) 代码块,否则仍可能抛并发修改异常。Vector、Hashtable 的迭代同理,需要在外部持有锁。
10.12 需要并发有序 Map 应该用什么?和 TreeMap 有什么区别?
答: 用 ConcurrentSkipListMap。底层是跳表,通过多层链表索引实现 O(log n) 查找、插入、删除,并发修改只涉及局部节点,配合 CAS 保证线程安全。TreeMap 基于红黑树,非线程安全,并发写入需要外部加锁;红黑树的插入删除可能引发全局平衡调整,高并发下需要全局锁。跳表局部修改更适合并发场景,且遍历结果按 key 有序。
十一、总结
本篇围绕 Java 集合的线程安全展开,核心结论可以压缩为以下几点:
- 普通集合
ArrayList、HashMap在多线程共享下会出现元素丢失、覆盖、越界与并发修改异常,根因是原子性、可见性缺失与复合操作竞争。 - 线程安全集合的解决思路分三类:外部同步与包装器、JUC 并发容器、不可变容器;现代项目优先使用 JUC 并发容器。
- 并发容器的演进主线是锁粒度不断变细:全表锁到分段锁,再到桶级锁与 CAS 无锁;读操作尽量脱离锁,写时复制进一步把读性能推到极致。
- 选型先看数据结构类型(Map、List、Queue),再看读写比例、有序性与是否需要阻塞:Map 默认
ConcurrentHashMap,有序用ConcurrentSkipListMap;List 读多写少用CopyOnWriteArrayList;生产者消费者用BlockingQueue;只读共享数据用不可变集合。 - 代码层面记住两个实践细节:check-then-act 用容器原子方法;包装同步集合的迭代必须手动加锁。
集合是并发编程的基本功,也是面试中出现频率最高的板块之一。把原理、选型和代码模板对应起来理解,遇到生产问题时就能快速定位到是集合共享、锁粒度还是读写比例的问题。
本文为原创文章,如需转载,请联系作者获得授权,并注明出处。