'# Java线程安全的List
一、背景与问题
在多线程编程中，线程安全是必须考虑的核心问题。Java的List接口提供了多种实现类，如ArrayList、LinkedList等，但这些实现默认不是线程安全的。当多个线程同时访问这些数据结构时，可能出现数据不一致、数据丢失、程序崩溃等严重问题。
例如，在以下场景中，即使使用ArrayList也可能导致并发问题：
List<String> list = new ArrayList<>();
// 多个线程同时执行以下操作
list.add("Thread1");
list.add("Thread2");当多个线程同时调用add方法时，可能因为竞态条件导致数据不一致。为了解决这一问题，Java提供了多种线程安全的List实现，本文将深入探讨这些实现的原理、使用场景以及实际开发中的注意事项。
二、基本原理
1. 线程安全的定义
线程安全是指在多线程环境下，数据结构的操作（如读、写、遍历）不会导致数据不一致或程序异常。实现线程安全的常见方式有：
- 内部锁（synchronized）：在关键代码块或方法上加锁，确保同一时刻只有一个线程执行。
- 分段锁（Segmented Locking）：将数据结构划分为多个段，每个段独立加锁，提升并发性能。
- 无锁算法（CAS + volatile）：通过原子操作和内存可见性保证线程安全。
2. Java线程安全List的实现
Java提供了三种主要的线程安全List实现：
| 实现类 | 线程安全机制 | 适用场景 | 性能特点 |
|---|---|---|---|
Vector | 内部方法加synchronized锁 | 低并发写、高并发读 | 读写性能较差 |
CopyOnWriteArrayList | 每次写操作复制新数组 | 高并发读、低并发写 | 写性能较差，读性能高 |
Collections.synchronizedList() | 包裹原始List加锁 | 通用场景 | 读写性能适中 |
三、环境准备
确保开发环境支持Java 8及以上版本，代码示例基于标准Java库。需要引入的依赖（如Spring Boot等框架）可忽略，本文仅讨论标准库。
四、核心实现
1. Vector：内置锁的List
Vector是Java最早的线程安全List实现，其核心机制是对每个方法加synchronized锁。这种方式简单但性能较差，因为所有操作都串行化。
代码示例：
import java.util.Vector;
public class VectorExample {
public static void main(String[] args) {
Vector<String> vector = new Vector<>();
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
vector.add("Thread1-" + i);
}
});
Thread thread2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
vector.add("Thread2-" + i);
}
});
thread1.start();
thread2.start();
try {
thread1.join();
thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Vector size: " + vector.size());
}
}关键代码解释：
Vector的add方法内部加了synchronized锁，确保同一时间只有一个线程执行写操作。- 这种机制在读取时也可能阻塞，因为锁粒度较大。
性能问题：
在高并发写场景下，Vector的性能显著低于CopyOnWriteArrayList，因为每次写操作都需加锁。
2. CopyOnWriteArrayList：写时复制
CopyOnWriteArrayList通过写时复制（Copy-on-Write）机制实现线程安全。其核心思想是：在写操作时复制整个数组，读操作则直接读取原数组。这种设计适用于高并发读、低并发写的场景。
代码示例：
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
public class CopyOnWriteExample {
public static void main(String[] args) {
List<String> list = new CopyOnWriteArrayList<>();
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
list.add("Thread1-" + i);
}
});
Thread thread2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
list.add("Thread2-" + i);
}
});
thread1.start();
thread2.start();
try {
thread1.join();
thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("CopyOnWriteArrayList size: " + list.size());
}
}关键代码解释：
CopyOnWriteArrayList的add方法会在内部创建一个新的数组副本，并将旧数组替换为新数组。- 读操作始终操作原数组，因此不会阻塞写操作。
性能问题：
- 写性能较差：每次写操作需要复制整个数组，时间复杂度为O(n)。
- 读性能高：读操作无需加锁，可并发读取。
3. Collections.synchronizedList：外部锁
Collections.synchronizedList通过包装原始List并为其加锁实现线程安全。它本质上是通过synchronized关键字对整个列表加锁，适用于需要灵活控制锁粒度的场景。
代码示例：
import java.util.Collections;
import java.util.List;
import java.util.ArrayList;
public class SynchronizedListExample {
public static void main(String[] args) {
List<String> list = Collections.synchronizedList(new ArrayList<>());
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
list.add("Thread1-" + i);
}
});
Thread thread2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
list.add("Thread2-" + i);
}
});
thread1.start();
thread2.start();
try {
thread1.join();
thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("SynchronizedList size: " + list.size());
}
}关键代码解释：
Collections.synchronizedList返回的List在内部方法上加锁，例如add、get等。- 但遍历操作需要手动加锁，否则可能引发
ConcurrentModificationException。
常见错误：
List<String> list = Collections.synchronizedList(new ArrayList<>());
// 错误：遍历时未加锁，可能导致并发修改异常
for (String s : list) {
System.out.println(s);
}解决办法：
使用Collections.synchronizedList时，遍历操作需手动加锁：
List<String> list = Collections.synchronizedList(new ArrayList<>());
synchronized (list) {
for (String s : list) {
System.out.println(s);
}
}五、完整案例
场景：多线程统计日志
假设需要统计多个线程产生的日志，要求最终结果准确。使用CopyOnWriteArrayList和Vector进行对比。
完整案例代码：
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.Vector;
public class ThreadSafeListCase {
public static void main(String[] args) throws InterruptedException {
// 使用CopyOnWriteArrayList
List<String> copyOnWriteList = new CopyOnWriteArrayList<>();
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
copyOnWriteList.add("CopyOnWrite-" + i);
}
});
Thread thread2 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
copyOnWriteList.add("CopyOnWrite-" + i);
}
});
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println("CopyOnWriteList size: " + copyOnWriteList.size());
// 使用Vector
Vector<String> vector = new Vector<>();
Thread thread3 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
vector.add("Vector-" + i);
}
});
Thread thread4 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
vector.add("Vector-" + i);
}
});
thread3.start();
thread4.start();
thread3.join();
thread4.join();
System.out.println("Vector size: " + vector.size());
}
}运行结果：
CopyOnWriteList size: 20000
Vector size: 20000分析：
CopyOnWriteArrayList在写操作时复制数组，确保读操作不会阻塞。Vector在写操作时加锁，导致写线程串行化。
六、源码解析
1. Vector 的实现原理
Vector的add方法内部使用synchronized关键字加锁：
public synchronized boolean add(E e) {
modCount++;
addElement(e);
}每次调用add时都会加锁，导致写操作串行化。
2. CopyOnWriteArrayList 的实现原理
CopyOnWriteArrayList的add方法在内部创建新数组：
public boolean add(E e) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] newElements;
final int s = size;
Object[] elements = elementData;
if (s == elements.length) {
newElements = Arrays.copyOf(elements, s + 1);
} else {
newElements = elements;
}
elements[s] = e;
setThreshold(s + 1);
return true;
} finally {
lock.unlock();
}
}每次写操作都会复制整个数组，读操作直接操作原数组。
3. Collections.synchronizedList 的实现原理
Collections.synchronizedList返回的List在方法上加锁：
public static <E> List<E> synchronizedList(List<E> list) {
return new SynchronizedList<>(list);
}SynchronizedList的add方法内部使用synchronized：
public synchronized boolean add(E e) {
modCount++;
addElement(e);
}七、进阶使用
1. 使用读写锁优化性能
对于需要频繁读取的场景，可以使用ReentrantReadWriteLock手动控制锁粒度：
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadWriteLockExample {
private final CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
public void add(String s) {
lock.writeLock().lock();
try {
list.add(s);
} finally {
lock.writeLock().unlock();
}
}
public List<String> read() {
lock.readLock().lock();
try {
return new ArrayList<>(list);
} finally {
lock.readLock().unlock();
}
}
}2. 使用分段锁（Segmented Locking）
对于高并发场景，可以使用ConcurrentHashMap的分段锁机制，但需注意List本身不支持分段锁。
八、性能与工程实践
1. 性能优化
- 高并发读：优先选择
CopyOnWriteArrayList，其读操作无锁。 - 高并发写：避免使用
Vector，因其写操作串行化。 - 混合读写：使用
Collections.synchronizedList并手动控制锁粒度。
2. 异常处理
- 并发修改异常：使用
CopyOnWriteArrayList时，遍历操作不会抛出ConcurrentModificationException。 - 死锁风险：在使用
ReentrantLock时，需注意锁的顺序。
3. 安全风险
- 数据一致性：
CopyOnWriteArrayList在写操作时复制数组，可能导致读取到旧数据。 - 内存泄漏：
Vector的elementData数组可能未及时回收，需手动清理。
九、常见问题与踩坑
1. 遍历异常
错误示例：
List<String> list = new CopyOnWriteArrayList<>();
list.add("A");
list.add("B");
for (String s : list) {
System.out.println(s);
}问题分析： CopyOnWriteArrayList的遍历不会抛出ConcurrentModificationException，但无法保证读取到最新数据。
2. 锁粒度过大
错误示例：
List<String> list = Collections.synchronizedList(new ArrayList<>());
for (String s : list) {
System.out.println(s);
}问题分析：
遍历时未加锁，可能导致ConcurrentModificationException。
3. 写性能瓶颈
错误示例：
List<String> list = new CopyOnWriteArrayList<>();
for (int i = 0; i < 1000000; i++) {
list.add("Data-" + i);
}问题分析：
频繁写操作会导致大量内存复制，降低性能。
十、最佳实践
1. 选择合适的实现
- 高并发读：使用
CopyOnWriteArrayList。 - 高并发写：使用
Vector（不推荐）或自定义锁。 - 通用场景：使用
Collections.synchronizedList并手动控制锁。
2. 避免锁粒度过大
- 对于读多写少的场景，使用
CopyOnWriteArrayList。 - 对于写多读少的场景，使用分段锁或
ReentrantReadWriteLock。
3. 注意遍历安全
CopyOnWriteArrayList的遍历不会抛出异常，但可能读取到旧数据。Collections.synchronizedList的遍历需手动加锁。
4. 性能调优
- 对于高并发写场景，可以使用
ConcurrentHashMap的分段锁机制。 - 对于高并发读场景，使用
CopyOnWriteArrayList的无锁读。
十一、总结
Java线程安全的List实现主要有Vector、CopyOnWriteArrayList和Collections.synchronizedList三种。它们分别通过内部锁、写时复制和外部锁实现线程安全，适用于不同场景：
Vector适合低并发写、高并发读的场景，但性能较差。CopyOnWriteArrayList适合高并发读、低并发写的场景，但写性能较差。Collections.synchronizedList适合通用场景，但需注意锁粒度和遍历安全。
在实际开发中，应根据具体需求选择合适的实现，避免因锁粒度过大或写性能瓶颈导致程序性能下降。同时，注意遍历安全和数据一致性问题，确保程序在多线程环境下稳定运行。