CopyOnWriteArrayList：读多写少场景下的并发利器

读写分离的妙用

想象你在图书馆查阅资料：

• 传统做法：有人借书时整个图书馆闭馆（类似Vector全表锁）
• 现代做法：读者可以继续阅读书架上的书，管理员在后台准备新版书籍（CopyOnWrite机制）

这就是CopyOnWriteArrayList的核心思想！今天我们就来深入探讨这个"读写分离"的并发列表实现。

---

一、基础认知：COW是什么？

1. 核心特点演示

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
list.add("Java"); // 写操作
list.add("Python");

// 读操作可以并发执行
list.forEach(System.out::println); // 安全遍历

2. 关键特性速览

特性	说明
写时复制	修改操作时复制整个数组
读操作无锁	所有读取操作都不需要同步
弱一致性	迭代器反映的是创建时的数组快照
适用场景	读多写少（如监听器列表、配置信息等）

---

二、底层原理：写时复制的魔法

1. 数据结构图解

• volatile数组引用：保证内存可见性
• ReentrantLock：写操作互斥

2. 写操作流程

---

三、四大典型应用场景

场景1：事件监听器列表

// 观察者模式的安全实现
class EventSource {
    private CopyOnWriteArrayList<Listener> listeners 
        = new CopyOnWriteArrayList<>();
    
    void addListener(Listener l) { listeners.add(l); }
    
    void fireEvent(Event e) {
        for (Listener l : listeners) { // 安全遍历
            l.onEvent(e);
        }
    }
}

场景2：配置信息管理

// 全局配置的热更新
CopyOnWriteArrayList<Config> configs = new CopyOnWriteArrayList<>();

// 后台线程定期更新
void reloadConfigs() {
    Config[] newConfigs = loadConfigsFromDB();
    configs = new CopyOnWriteArrayList<>(newConfigs);
}

// 业务线程安全读取
String getConfig(String key) {
    for (Config c : configs) { /*...*/ }
}

场景3：黑白名单过滤

// 动态更新的IP白名单
CopyOnWriteArrayList<String> whiteList = new CopyOnWriteArrayList<>();

boolean allowAccess(String ip) {
    return whiteList.contains(ip); // 安全读取
}

void updateList(List<String> newIps) {
    whiteList = new CopyOnWriteArrayList<>(newIps); // 原子替换
}

场景4：日志处理系统

// 多线程日志收集
CopyOnWriteArrayList<String> logBuffer = new CopyOnWriteArrayList<>();

// 日志写入线程
void log(String message) {
    logBuffer.add(message);
}

// 日志处理线程（定期批量处理）
void processLogs() {
    for (String log : logBuffer) {
        // 处理日志...
    }
    logBuffer.clear();
}

---

四、性能特点与注意事项

1. 性能对比测试（10万次操作）

操作	ArrayList	Vector	CopyOnWriteArrayList
读(get)	5ms	120ms	8ms
写(add)	7ms	150ms	250ms
迭代	6ms	130ms	10ms

2. 使用注意事项

// 错误用法：频繁写入
CopyOnWriteArrayList<Integer> data = new CopyOnWriteArrayList<>();
for (int i = 0; i < 100000; i++) { // 导致大量数组拷贝！
    data.add(i);
}

// 正确用法：批量添加
data.addAll(Arrays.asList(numbers)); // 单次复制

---

五、源码级揭秘：关键实现细节

1. 写操作实现（JDK17源码片段）

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); // volatile写保证可见性
        return true;
    } finally {
        lock.unlock();
    }
}

2. 迭代器实现

static final class COWIterator<E> implements ListIterator<E> {
    private final Object[] snapshot; // 创建时的数组快照
    private int cursor;
    
    public E next() {
        if (!hasNext()) throw new NoSuchElementException();
        return (E) snapshot[cursor++];
    }
}

---

六、与相关容器的对比

特性	ArrayList	Vector	CopyOnWriteArrayList
线程安全	❌	✅(全表锁)	✅(写时复制)
读性能	⭐⭐⭐⭐⭐	⭐⭐	⭐⭐⭐⭐
写性能	⭐⭐⭐⭐⭐	⭐⭐	⭐
迭代安全	❌	✅(同步)	✅(快照)
内存占用	低	低	高(写时复制副本)

---

七、最佳实践指南

1. 选型决策树

2. 优化建议

• 预分配空间：在已知大小时通过构造函数指定
• 批量操作：优先使用addAll而不是循环add
• 避免size()：遍历时直接使用迭代器

3. 替代方案

当写操作较多时考虑：

// 并发队列方案
ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();

// 并发Map方案
ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();

---

结语：合适的就是最好的

CopyOnWriteArrayList就像：

• 📚 图书馆的影印服务：不影响读者阅读原版
• 🕰️ 时间机器：迭代器看到的是过去的快照
• 🛡️ 读写盾牌：完美隔离读写操作

记住它的黄金使用场景：读多写少且数据量不大的情况。用对了场景，它就是你并发编程中的神兵利器！