Java面试要点50 - List的线程安全实现：CopyOnWriteArrayList

---

一、引入

在并发编程中,线程安全的集合类扮演着重要角色。CopyOnWriteArrayList作为List接口的线程安全实现,采用了一种独特的"写时复制"机制来保证线程安全。

二、实现原理解析

2.1 写时复制机制

CopyOnWriteArrayList的核心思想是在执行写操作时,先复制一个新的数组,在新数组上进行修改,最后将新数组替换旧数组。这种机制保证了读操作不需要加锁,从而大大提升了读操作的性能。

以下是其核心实现原理的示例代码：

public class CopyOnWriteArrayList<E> implements List<E> {private transient volatile Object[] array;final Object[] getArray() {return array;}final void setArray(Object[] a) {array = a;}public boolean add(E e) {final ReentrantLock lock = this.lock;lock.lock();try {Object[] elements = getArray();int len = elements.length;Object[] newElements = Arrays.copyOf(elements, len + 1);newElements[len] = e;setArray(newElements);return true;} finally {lock.unlock();}}
}

2.2 读写分离策略

CopyOnWriteArrayList在读操作时不需要加锁,因为内部数组array使用volatile修饰,保证了数组引用的可见性。写操作则通过ReentrantLock来保证同步。这种读写分离的策略使其特别适合读多写少的场景。

以下是其读写操作的核心实现：

public class CopyOnWriteArrayList<E> {// volatile修饰的数组引用,保证可见性private transient volatile Object[] array;// 用于写操作的锁final transient ReentrantLock lock = new ReentrantLock();// 读操作不需要加锁,直接返回数组元素public E get(int index) {return get(getArray(), index);}private E get(Object[] a, int index) {return (E) a[index];}// 写操作需要加锁,并复制数组public E set(int index, E element) {final ReentrantLock lock = this.lock;lock.lock(); // 加锁保护写操作try {Object[] elements = getArray();E oldValue = get(elements, index);if (oldValue != element) {// 复制数组并修改指定位置的值int len = elements.length;Object[] newElements = Arrays.copyOf(elements, len);newElements[index] = element;setArray(newElements);}return oldValue;} finally {lock.unlock(); // 确保锁的释放}}// 迭代操作也不需要加锁,因为使用的是数组的快照public Iterator<E> iterator() {return new COWIterator<E>(getArray(), 0);}// 内部迭代器实现static final class COWIterator<E> implements Iterator<E> {private final Object[] snapshot;private int cursor;COWIterator(Object[] elements, int initialCursor) {cursor = initialCursor;snapshot = elements; // 保存当前数组的快照}public boolean hasNext() {return cursor < snapshot.length;}@SuppressWarnings("unchecked")public E next() {if (!hasNext())throw new NoSuchElementException();return (E) snapshot[cursor++];}}
}

这种实现方式使得读操作的性能非常高，因为完全不需要加锁，而写操作虽然会复制数组，但通过加锁机制保证了数据的一致性。

三、性能测试分析

通过一个实际的性能测试来了解CopyOnWriteArrayList在不同场景下的表现：

public class CopyOnWriteArrayListTest {private static final int THREAD_COUNT = 10;private static final int OPERATION_COUNT = 1000;public static void main(String[] args) throws InterruptedException {// 初始化测试数据List<String> copyOnWriteList = new CopyOnWriteArrayList<>();List<String> synchronizedList = Collections.synchronizedList(new ArrayList<>());// 测试并发写性能CountDownLatch writeLatch = new CountDownLatch(THREAD_COUNT);long writeStartTime = System.nanoTime();for (int i = 0; i < THREAD_COUNT; i++) {new Thread(() -> {for (int j = 0; j < OPERATION_COUNT; j++) {copyOnWriteList.add("Item " + j);}writeLatch.countDown();}).start();}writeLatch.await();long writeTime = System.nanoTime() - writeStartTime;System.out.printf("CopyOnWriteArrayList写入耗时: %d ms%n", writeTime / 1_000_000);// 测试并发读性能CountDownLatch readLatch = new CountDownLatch(THREAD_COUNT);long readStartTime = System.nanoTime();for (int i = 0; i < THREAD_COUNT; i++) {new Thread(() -> {for (int j = 0; j < OPERATION_COUNT; j++) {copyOnWriteList.get(j % copyOnWriteList.size());}readLatch.countDown();}).start();}readLatch.await();long readTime = System.nanoTime() - readStartTime;System.out.printf("CopyOnWriteArrayList读取耗时: %d ms%n", readTime / 1_000_000);}
}

四、应用场景分析

4.1 事件监听器管理

CopyOnWriteArrayList非常适合用于管理事件监听器列表,因为监听器的注册和移除操作相对较少,而事件触发时需要频繁遍历通知所有监听器：

public class EventManager {private final List<EventListener> listeners = new CopyOnWriteArrayList<>();public void addEventListener(EventListener listener) {listeners.add(listener);}public void removeEventListener(EventListener listener) {listeners.remove(listener);}public void fireEvent(Event event) {for (EventListener listener : listeners) {listener.onEvent(event);}}
}

4.2 缓存实现

在读多写少的缓存场景中,CopyOnWriteArrayList也能发挥其优势：

public class CacheManager<T> {private final List<T> cache = new CopyOnWriteArrayList<>();public void updateCache(List<T> newData) {cache.clear();cache.addAll(newData);}public List<T> getCache() {return new ArrayList<>(cache);  // 返回副本,避免外部修改}public T getCacheItem(int index) {return cache.get(index);}
}

五、最佳实践建议

5.1 性能优化技巧

在使用CopyOnWriteArrayList时,我们需要注意一些性能优化的关键点：

public class OptimizedListOperations {private final List<String> list = new CopyOnWriteArrayList<>();// 批量添加优化public void batchAdd(Collection<String> items) {// 一次性复制,而不是逐个添加List<String> currentList = new ArrayList<>(list);currentList.addAll(items);((CopyOnWriteArrayList<String>)list).setArray(currentList.toArray());}// 迭代时的快照语义public void processItems() {// 利用快照特性,整个迭代过程使用同一个数组for (String item : list) {processItem(item);}}private void processItem(String item) {// 处理单个元素的业务逻辑}
}

5.2 常见陷阱规避

在使用CopyOnWriteArrayList时要注意规避一些常见的性能陷阱：

public class ListUsageGuide {private final CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();// 避免频繁修改操作public void wrongUsage() {// 错误示范：频繁修改导致性能问题for (int i = 0; i < 10000; i++) {list.add("item" + i);  // 每次add都会复制整个数组}}// 正确的使用方式public void correctUsage() {// 正确示范：批量操作ArrayList<String> temp = new ArrayList<>();for (int i = 0; i < 10000; i++) {temp.add("item" + i);}list.addAll(temp);  // 只复制一次数组}
}

总结

CopyOnWriteArrayList通过其独特的写时复制机制,在保证线程安全的同时,为读多写少的并发场景提供了excellent的解决方案。它的核心优势在于读操作完全不需要加锁,从而能够提供更好的读性能。不过,这种实现机制也带来了写操作的开销,因为每次修改都需要复制整个数组。

在实际应用中,需要权衡使用场景的特点来决定是否使用CopyOnWriteArrayList。对于事件监听器列表、配置信息等读多写少的场景,CopyOnWriteArrayList是一个理想的选择。而对于写操作频繁的场景,可能需要考虑其他的线程安全集合实现。