探秘 Java CopyOnWriteArrayList：源码级深入剖析其使用原理
一、引言
在 Java 的并发编程领域，线程安全的数据结构起着至关重要的作用。当多个线程同时访问和修改数据时，如何确保数据的一致性和完整性是一个关键问题。CopyOnWriteArrayList 作为 Java 并发包（java.util.concurrent）中的一员，为解决多线程环境下的列表操作问题提供了一种独特而有效的方案。
CopyOnWriteArrayList 是一个线程安全的变体，它的设计理念基于“写时复制”（Copy-On-Write）机制。简单来说，当对 CopyOnWriteArrayList 进行写操作（如添加、删除元素）时，它会创建一个原数组的副本，在副本上进行修改，修改完成后再将副本替换原数组。而读操作则可以直接在原数组上进行，无需加锁。这种机制使得读操作可以无锁地并发执行，从而提高了读操作的性能，特别适用于读多写少的场景。
本文将深入剖析 CopyOnWriteArrayList 的使用原理，从源码的角度详细解读其内部实现。我们将逐步分析其构造方法、核心操作方法（如添加、删除、查找元素）以及并发控制机制，通过实际的代码示例和详细的注释，帮助读者更好地理解 CopyOnWriteArrayList 的工作原理。同时，我们还将探讨其性能特点、适用场景以及与其他列表实现的比较。通过阅读本文，你将对 CopyOnWriteArrayList 有一个全面而深入的了解，能够在实际项目中更加合理地运用它。
二、CopyOnWriteArrayList 概述
2.1 什么是 CopyOnWriteArrayList
CopyOnWriteArrayList 是 Java 并发包中提供的一个线程安全的列表实现，它实现了 List 接口，因此可以像使用普通列表一样使用它。与传统的线程安全列表（如 Vector）不同，CopyOnWriteArrayList 采用了写时复制的机制，避免了在大多数读操作时加锁，从而提高了并发性能。
2.2 CopyOnWriteArrayList 的特点
- 线程安全：
CopyOnWriteArrayList保证了在多线程环境下对列表的操作是线程安全的，无需额外的同步机制。 - 读操作无锁：读操作（如
get、iterator等）可以无锁地并发执行，不会阻塞其他线程的读操作，提高了读操作的性能。 - 写时复制：写操作（如
add、remove等）会创建一个原数组的副本，在副本上进行修改，修改完成后再将副本替换原数组。这种机制保证了写操作的原子性，但会带来一定的内存开销和写操作性能损耗。 - 弱一致性迭代器：
CopyOnWriteArrayList的迭代器是弱一致性的，即迭代器创建时会基于当时的数组状态，在迭代过程中如果其他线程对列表进行了修改，迭代器不会反映这些修改，仍然会遍历迭代器创建时的数组元素。
2.3 CopyOnWriteArrayList 的应用场景
由于 CopyOnWriteArrayList 读操作无锁的特性，它特别适用于读多写少的场景，例如：
- 配置信息存储：在一些系统中，配置信息通常只需要在启动时加载，之后很少修改，但会被多个线程频繁读取。使用
CopyOnWriteArrayList可以高效地存储和读取这些配置信息。 - 事件监听器列表：在事件驱动的系统中，事件监听器列表通常只在系统初始化时注册，之后很少修改，但会被频繁地遍历以触发事件。
CopyOnWriteArrayList可以很好地满足这种读多写少的需求。
三、CopyOnWriteArrayList 源码分析
3.1 类的定义和成员变量
// java.util.concurrent.CopyOnWriteArrayList 类的定义，实现了 List、RandomAccess、Cloneable 和 Serializable 接口
public class CopyOnWriteArrayList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
// 用于序列化和反序列化的版本号
private static final long serialVersionUID = 8673264195747942595L;
// 可重入锁，用于保护写操作
final transient ReentrantLock lock = new ReentrantLock();
// 存储列表元素的数组
private transient volatile Object[] array;
// 获取存储元素的数组
final Object[] getArray() {
return array;
}
// 设置存储元素的数组
final void setArray(Object[] a) {
array = a;
}
// 构造方法，创建一个空的 CopyOnWriteArrayList
public CopyOnWriteArrayList() {
// 调用 setArray 方法，将数组初始化为空数组
setArray(new Object[0]);
}
// 构造方法，使用指定集合的元素初始化 CopyOnWriteArrayList
public CopyOnWriteArrayList(Collection<? extends E> c) {
Object[] elements;
if (c.getClass() == CopyOnWriteArrayList.class)
// 如果传入的集合是 CopyOnWriteArrayList 类型，直接获取其数组
elements = ((CopyOnWriteArrayList<?>)c).getArray();
else {
// 否则，将集合转换为数组
elements = c.toArray();
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elements.getClass() != Object[].class)
// 如果数组类型不是 Object[]，则进行复制
elements = Arrays.copyOf(elements, elements.length, Object[].class);
}
// 调用 setArray 方法，设置数组
setArray(elements);
}
// 构造方法，使用指定数组的元素初始化 CopyOnWriteArrayList
public CopyOnWriteArrayList(E[] toCopyIn) {
// 调用 setArray 方法，将数组复制到 array 中
setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
}
}
在上述代码中，CopyOnWriteArrayList 类实现了 List、RandomAccess、Cloneable 和 Serializable 接口，表明它具有列表的基本功能，支持随机访问、克隆和序列化。lock 是一个可重入锁，用于保护写操作，确保写操作的原子性。array 是一个 volatile 修饰的数组，用于存储列表的元素。volatile 关键字保证了数组的可见性，即一个线程对数组的修改会立即被其他线程看到。
构造方法提供了多种初始化方式，包括创建一个空的列表、使用指定集合的元素初始化列表和使用指定数组的元素初始化列表。
3.2 核心操作方法
3.2.1 添加元素（add 方法）
// 在列表末尾添加元素的方法
public boolean add(E e) {
// 获取可重入锁
final ReentrantLock lock = this.lock;
// 加锁，确保写操作的原子性
lock.lock();
try {
// 获取当前数组
Object[] elements = getArray();
// 获取数组的长度
int len = elements.length;
// 创建一个新的数组，长度比原数组大 1
Object[] newElements = Arrays.copyOf(elements, len + 1);
// 将新元素添加到新数组的末尾
newElements[len] = e;
// 设置新数组为当前数组
setArray(newElements);
// 返回添加成功的标志
return true;
} finally {
// 释放锁
lock.unlock();
}
}
// 在指定位置添加元素的方法
public void add(int index, E element) {
// 获取可重入锁
final ReentrantLock lock = this.lock;
// 加锁，确保写操作的原子性
lock.lock();
try {
// 获取当前数组
Object[] elements = getArray();
// 获取数组的长度
int len = elements.length;
// 检查索引是否越界
if (index > len || index < 0)
// 若越界，抛出 IndexOutOfBoundsException 异常
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+len);
Object[] newElements;
// 计算需要移动的元素数量
int numMoved = len - index;
if (numMoved == 0)
// 如果不需要移动元素，直接复制原数组并增加长度
newElements = Arrays.copyOf(elements, len + 1);
else {
// 否则，创建一个新数组，将原数组的元素复制到新数组中
newElements = new Object[len + 1];
// 复制原数组中索引小于 index 的元素
System.arraycopy(elements, 0, newElements, 0, index);
// 复制原数组中索引大于等于 index 的元素
System.arraycopy(elements, index, newElements, index + 1,
numMoved);
}
// 将新元素插入到指定位置
newElements[index] = element;
// 设置新数组为当前数组
setArray(newElements);
} finally {
// 释放锁
lock.unlock();
}
}
add(E e) 方法用于在列表末尾添加元素。它首先获取可重入锁，确保写操作的原子性。然后获取当前数组，创建一个新的数组，长度比原数组大 1，并将原数组的元素复制到新数组中，最后将新元素添加到新数组的末尾。最后，设置新数组为当前数组，并释放锁。
add(int index, E element) 方法用于在指定位置添加元素。它同样先获取可重入锁，然后检查索引是否越界。如果需要移动元素，会创建一个新数组，并将原数组的元素复制到新数组中，将新元素插入到指定位置。最后，设置新数组为当前数组，并释放锁。
3.2.2 删除元素（remove 方法）
// 删除指定位置元素的方法
public E remove(int index) {
// 获取可重入锁
final ReentrantLock lock = this.lock;
// 加锁，确保写操作的原子性
lock.lock();
try {
// 获取当前数组
Object[] elements = getArray();
// 获取数组的长度
int len = elements.length;
// 获取要删除的元素
E oldValue = get(elements, index);
// 计算需要移动的元素数量
int numMoved = len - index - 1;
if (numMoved == 0)
// 如果不需要移动元素，直接复制原数组并减少长度
setArray(Arrays.copyOf(elements, len - 1));
else {
// 否则，创建一个新数组，将原数组的元素复制到新数组中
Object[] newElements = new Object[len - 1];
// 复制原数组中索引小于 index 的元素
System.arraycopy(elements, 0, newElements, 0, index);
// 复制原数组中索引大于 index 的元素
System.arraycopy(elements, index + 1, newElements, index,
numMoved);
// 设置新数组为当前数组
setArray(newElements);
}
// 返回被删除的元素
return oldValue;
} finally {
// 释放锁
lock.unlock();
}
}
// 删除指定元素的方法
public boolean remove(Object o) {
// 获取当前数组
Object[] snapshot = getArray();
// 查找元素的索引
int index = indexOf(o, snapshot, 0, snapshot.length);
// 如果元素不存在，返回 false
return (index < 0) ? false : remove(o, snapshot, index);
}
// 内部删除指定元素的方法
private boolean remove(Object o, Object[] snapshot, int index) {
// 获取可重入锁
final ReentrantLock lock = this.lock;
// 加锁，确保写操作的原子性
lock.lock();
try {
// 获取当前数组
Object[] current = getArray();
// 获取数组的长度
int len = current.length;
// 检查快照是否与当前数组相同
if (snapshot != current) findIndex: {
// 计算搜索的起始位置
int prefix = Math.min(index, len);
// 检查前缀部分是否相同
for (int i = 0; i < prefix; i++) {
if (current[i] != snapshot[i] && eq(o, current[i])) {
// 如果找到元素，更新索引
index = i;
break findIndex;
}
}
// 如果索引超出当前数组长度，返回 false
if (index >= len)
return false;
// 如果当前位置的元素不等于要删除的元素
if (current[index] != o) {
// 重新查找元素的索引
index = indexOf(o, current, index, len);
// 如果元素不存在，返回 false
if (index < 0)
return false;
}
}
// 创建一个新数组，长度比原数组小 1
Object[] newElements = new Object[len - 1];
// 复制原数组中索引小于 index 的元素
System.arraycopy(current, 0, newElements, 0, index);
// 复制原数组中索引大于 index 的元素
System.arraycopy(current, index + 1, newElements, index,
len - index - 1);
// 设置新数组为当前数组
setArray(newElements);
// 返回删除成功的标志
return true;
} finally {
// 释放锁
lock.unlock();
}
}
remove(int index) 方法用于删除指定位置的元素。它首先获取可重入锁，然后获取当前数组和要删除的元素。根据需要移动的元素数量，创建一个新数组，并将原数组的元素复制到新数组中，最后设置新数组为当前数组，并返回被删除的元素。
remove(Object o) 方法用于删除指定元素。它首先获取当前数组的快照，查找元素的索引。如果元素存在，则调用内部的 remove 方法进行删除。
remove(Object o, Object[] snapshot, int index) 方法是内部删除方法，它会再次检查当前数组是否与快照相同，如果不同，会重新查找元素的索引。然后创建一个新数组，将原数组的元素复制到新数组中，最后设置新数组为当前数组，并返回删除成功的标志。
3.2.3 获取元素（get 方法）
// 获取指定位置元素的方法
public E get(int index) {
// 调用 get 方法，传入当前数组和索引
return get(getArray(), index);
}
// 内部获取指定位置元素的方法
private E get(Object[] a, int index) {
// 返回数组中指定位置的元素
return (E) a[index];
}
get(int index) 方法用于获取指定位置的元素。它首先调用 getArray 方法获取当前数组，然后调用内部的 get 方法返回数组中指定位置的元素。由于读操作不需要加锁，因此 get 方法可以无锁地并发执行。
3.3 迭代器
// 返回一个迭代器的方法
public Iterator<E> iterator() {
// 创建一个 COWIterator 迭代器实例
return new COWIterator<E>(getArray(), 0);
}
// COWIterator 迭代器类
static final class COWIterator<E> implements ListIterator<E> {
// 存储迭代器创建时的数组快照
private final Object[] snapshot;
// 当前迭代的索引
private int cursor;
// 构造方法，初始化迭代器
private COWIterator(Object[] elements, int initialCursor) {
// 初始化索引
cursor = initialCursor;
// 存储数组快照
snapshot = elements;
}
// 判断是否还有下一个元素的方法
public boolean hasNext() {
// 判断索引是否小于数组长度
return cursor < snapshot.length;
}
// 获取下一个元素的方法
public E next() {
// 检查是否还有下一个元素
if (! hasNext())
// 若没有，抛出 NoSuchElementException 异常
throw new NoSuchElementException();
// 返回当前索引的元素，并将索引加 1
return (E) snapshot[cursor++];
}
// 判断是否还有上一个元素的方法
public boolean hasPrevious() {
// 判断索引是否大于 0
return cursor > 0;
}
// 获取上一个元素的方法
public E previous() {
// 检查是否还有上一个元素
if (! hasPrevious())
// 若没有，抛出 NoSuchElementException 异常
throw new NoSuchElementException();
// 返回当前索引减 1 的元素，并将索引减 1
return (E) snapshot[--cursor];
}
// 获取下一个元素的索引的方法
public int nextIndex() {
// 返回当前索引
return cursor;
}
// 获取上一个元素的索引的方法
public int previousIndex() {
// 返回当前索引减 1
return cursor - 1;
}
// 移除当前元素的方法，不支持
public void remove() {
// 抛出 UnsupportedOperationException 异常
throw new UnsupportedOperationException();
}
// 设置当前元素的方法，不支持
public void set(E e) {
// 抛出 UnsupportedOperationException 异常
throw new UnsupportedOperationException();
}
// 添加元素的方法，不支持
public void add(E e) {
// 抛出 UnsupportedOperationException 异常
throw new UnsupportedOperationException();
}
}
CopyOnWriteArrayList 的迭代器是 COWIterator，它是一个弱一致性的迭代器。迭代器创建时会存储当前数组的快照，在迭代过程中不会反映其他线程对列表的修改。迭代器的 next、previous 等方法直接操作快照数组，因此不会受到其他线程写操作的影响。同时，迭代器的 remove、set 和 add 方法都不支持，因为这些操作可能会破坏快照的一致性。
3.4 并发控制机制
CopyOnWriteArrayList 的并发控制主要基于可重入锁 ReentrantLock 和 volatile 关键字。
- 可重入锁
ReentrantLock：在写操作（如add、remove等）时，会先获取可重入锁，确保写操作的原子性。同一时间只有一个线程可以获取锁并进行写操作，其他线程需要等待锁的释放。 volatile关键字：array数组使用volatile关键字修饰，保证了数组的可见性。当一个线程修改了数组的引用（即设置了新的数组），其他线程会立即看到这个修改。
四、CopyOnWriteArrayList 的性能分析
4.1 时间复杂度分析
- 添加元素（add 方法）：时间复杂度为 O(n)，因为需要复制原数组。在最坏情况下，每次添加元素都需要复制整个数组。
- 删除元素（remove 方法）：时间复杂度为 O(n)，因为需要复制原数组。在最坏情况下，每次删除元素都需要复制整个数组。
- 获取元素（get 方法）：时间复杂度为 O(1)，因为只需要根据索引直接访问数组元素。
- 迭代操作：时间复杂度为 O(n)，因为需要遍历整个数组。
4.2 空间复杂度分析
CopyOnWriteArrayList 的空间复杂度为 O(n)，其中 n 是列表中元素的数量。在写操作时，会创建一个原数组的副本，因此会额外占用 O(n) 的空间。
4.3 性能特点总结
- 读操作性能高：读操作（如
get、iterator等）不需要加锁，可以无锁地并发执行，因此读操作的性能非常高。 - 写操作性能低：写操作（如
add、remove等）需要复制原数组，会带来一定的内存开销和时间开销，因此写操作的性能相对较低。
五、CopyOnWriteArrayList 与其他列表实现的比较
5.1 与 Vector 的比较
- 线程安全机制：
Vector是通过synchronized关键字来保证线程安全的，所有的方法都是同步的，因此在多线程环境下，同一时间只有一个线程可以访问Vector的方法。而CopyOnWriteArrayList采用写时复制的机制，读操作不需要加锁，写操作使用可重入锁，提高了读操作的并发性能。 - 性能差异：在读多写少的场景下，
CopyOnWriteArrayList的性能优于Vector，因为CopyOnWriteArrayList的读操作无锁。但在写操作频繁的场景下，Vector的性能可能更好，因为CopyOnWriteArrayList的写操作需要复制数组，会带来较大的开销。
5.2 与 ArrayList 的比较
- 线程安全性：
ArrayList是非线程安全的，在多线程环境下需要额外的同步机制来保证线程安全。而CopyOnWriteArrayList是线程安全的，不需要额外的同步操作。 - 性能差异：在单线程环境下，
ArrayList的性能优于CopyOnWriteArrayList，因为ArrayList没有锁和数组复制的开销。但在多线程环境下，CopyOnWriteArrayList可以提供线程安全的操作，而ArrayList需要额外的同步开销。
六、CopyOnWriteArrayList 的使用注意事项
6.1 内存开销
由于 CopyOnWriteArrayList 在写操作时会创建一个原数组的副本，因此会带来一定的内存开销。在内存资源有限的情况下，需要谨慎使用。特别是在频繁进行写操作的场景下，可能会导致内存占用过高。
6.2 弱一致性
CopyOnWriteArrayList 的迭代器是弱一致性的，即迭代器创建时会基于当时的数组状态，在迭代过程中如果其他线程对列表进行了修改，迭代器不会反映这些修改。因此，在使用迭代器时需要注意数据的一致性问题。
6.3 适用场景
CopyOnWriteArrayList 适用于读多写少的场景，如配置信息存储、事件监听器列表等。在写操作频繁的场景下，不建议使用 CopyOnWriteArrayList，可以考虑使用其他线程安全的数据结构。
七、总结与展望
7.1 总结
CopyOnWriteArrayList 是 Java 并发包中一个独特的线程安全列表实现，它采用写时复制的机制，在多线程环境下提供了高效的读操作性能。通过源码分析，我们了解了它的内部实现原理，包括构造方法、核心操作方法、迭代器和并发控制机制。
CopyOnWriteArrayList 的核心思想是在写操作时创建一个原数组的副本，在副本上进行修改，修改完成后再将副本替换原数组。读操作可以直接在原数组上进行，无需加锁，从而提高了读操作的并发性能。但写操作需要复制数组，会带来一定的内存开销和时间开销，因此适用于读多写少的场景。
与其他列表实现（如 Vector 和 ArrayList）相比，CopyOnWriteArrayList 在不同的场景下具有不同的性能特点。在选择使用时，需要根据具体的业务需求和场景进行权衡。
7.2 展望
7.2.1 性能优化
虽然 CopyOnWriteArrayList 在读多写少的场景下具有较好的性能，但在写操作频繁的场景下，其性能仍然有待提高。未来可以研究如何减少写操作时的数组复制开销，例如采用增量复制的方式，只复制发生变化的部分。
7.2.2 功能扩展
可以为 CopyOnWriteArrayList 添加更多的功能，如支持批量操作、提供更丰富的迭代器接口等。同时，可以考虑将 CopyOnWriteArrayList 与其他数据结构进行结合，实现更复杂的功能。
7.2.3 应用场景拓展
随着计算机技术的不断发展，CopyOnWriteArrayList 的应用场景也将不断拓展。例如，在大数据、分布式系统等领域，需要处理大量的并发数据，CopyOnWriteArrayList 可以作为一种高效的数据存储和处理结构，为这些领域的应用提供支持。
总之，CopyOnWriteArrayList 是一个非常有价值的数据结构，通过不断的研究和优化，它将能够更好地满足各种复杂的应用需求。
以上博客从源码级别深入分析了 CopyOnWriteArrayList 的使用原理，包括其构造方法、核心操作方法、迭代器、并发控制机制等方面。同时，对其性能特点、与其他列表实现的比较以及使用注意事项进行了详细的讨论。最后，对 CopyOnWriteArrayList 的未来发展进行了展望。希望这篇博客能够帮助你更好地理解和使用 CopyOnWriteArrayList。如果你还有其他问题或需要进一步的帮助，请随时告诉我。
