JUC系列《深入浅出Java并发容器：CopyOnWriteArrayList全解析》

引言

在Java并发编程的世界里，我们常常需要在多线程环境下处理共享数据。传统的ArrayList虽然好用，但在多线程环境下却是个”定时炸弹”——非线程安全会导致数据不一致问题。JDK的java.util.concurrent包（简称JUC）为我们提供了一系列线程安全的容器，今天我们要重点剖析的就是其中一位”读写分离大师”——CopyOnWriteArrayList。

什么是CopyOnWriteArrayList？

CopyOnWriteArrayList是Java集合框架中的一个线程安全实现，它实现了List接口。与传统的通过同步锁实现线程安全的方式不同，它采用了一种更加巧妙的”写时复制”（Copy-On-Write）策略来保证线程安全。

简单来说，它就是：”写操作时复制一份，读操作无锁直接读”。

核心原理：写时复制

基本工作机制

读取操作：直接读取当前数组的内容，不需要任何同步控制
写入操作（add、set、remove等）：
获取锁（保证同一时间只有一个写操作）
复制当前数组到一个新数组中
在新数组上执行修改操作
将底层数组引用指向新数组
释放锁

// 简化版的写操作流程（伪代码表明）
public boolean add(E element) {
    synchronized (lock) {
        Object[] oldArray = currentArray;
        Object[] newArray = Arrays.copyOf(oldArray, oldArray.length + 1);
        newArray[newArray.length - 1] = element;
        currentArray = newArray; // 原子性操作，引用赋值是原子的
        return true;
    }
}

内存模型与可见性

由于对数组引用的赋值是原子操作，且配合volatile关键字保证可见性，读线程总能看到最新完成的写操作结果：

// JDK中的实际实现片段
public class CopyOnWriteArrayList<E> {
    private transient volatile Object[] array; // volatile保证可见性
    
    final Object[] getArray() {
        return array;
    }
    
    final void setArray(Object[] a) {
        array = a;
    }
}

代码示例：一看就懂

基础使用示例

import java.util.concurrent.CopyOnWriteArrayList;

public class CopyOnWriteArrayListDemo {
    public static void main(String[] args) {
        // 创建CopyOnWriteArrayList实例
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        
        // 添加元素 - 写操作
        list.add("Java");
        list.add("Python");
        list.add("Go");
        
        // 读取元素 - 读操作（无需同步）
        System.out.println("第一个元素: " + list.get(0));
        
        // 遍历操作也是线程安全的
        for (String language : list) {
            System.out.println("编程语言: " + language);
        }
        
        // 并发修改不会抛出ConcurrentModificationException
        list.remove("Python");
        System.out.println("删除后的列表: " + list);
    }
}

并发读写示例

import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ConcurrentReadWriteDemo {
    private static final CopyOnWriteArrayList<Integer> list = 
        new CopyOnWriteArrayList<>();
    
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(10);
        
        // 启动多个写线程
        for (int i = 0; i < 5; i++) {
            final int value = i;
            executor.execute(() -> {
                list.add(value);
                System.out.println("写入: " + value);
            });
        }
        
        // 启动多个读线程
        for (int i = 0; i < 5; i++) {
            executor.execute(() -> {
                System.out.println("读取: " + list);
            });
        }
        
        executor.shutdown();
        Thread.sleep(1000);
        System.out.println("最终结果: " + list);
    }
}

⚖️ 优缺点分析

✅ 优点

读取性能极高：读操作完全无锁，性能接近ArrayList
线程安全：不会出现ConcurrentModificationException
迭代器安全：迭代器遍历的是创建时的数组快照

❌ 缺点

内存占用大：每次写操作都会复制整个数组
数据最终一致性：读操作可能无法立即看到最新的修改
不适合写多读少的场景：频繁写操作会导致性能下降

适用场景

读多写少的场景：如黑名单、白名单配置
事件监听器列表：监听器很少变动，但频繁被遍历
缓存数据：数据不常常变化但需要高并发读取

// 典型应用：事件监听器管理
public class EventManager {
    private final CopyOnWriteArrayList<EventListener> listeners = 
        new CopyOnWriteArrayList<>();
    
    // 添加监听器（写操作少）
    public void addListener(EventListener listener) {
        listeners.add(listener);
    }
    
    // 触发事件（读操作多）
    public void fireEvent(Event event) {
        for (EventListener listener : listeners) {
            listener.onEvent(event); // 安全遍历
        }
    }
}

总结与展望

CopyOnWriteArrayList通过巧妙的”写时复制”机制，在保证线程安全的同时提供了极高的读性能。它是并发编程中”读写分离”思想的经典实现。

不过，技术选择从来都是权衡的艺术。在选择使用CopyOnWriteArrayList时，必定要根据实际业务场景来判断：如果你的应用是读多写少且数据量不大，那么它是绝佳选择；如果是写操作频繁的场景，可能需要思考其他并发容器如ConcurrentLinkedQueue或使用传统的同步机制。

随着Java版本的不断更新，JUC包也在持续演进。未来我们可以期待更多优化的并发容器出现，但在那之前，理解并合理使用现有的工具依旧是我们每个Java开发者的必备技能。