1. 回顾 ArrayList

ArrayList 是基于数组实现的动态数据，是线程不安全的。例如，我们在遍历 ArrayList 的时候，如果其他线程并发修改数组（当然也不一定是被其他线程修改），在迭代器中就会触发 fail-fast 机制，抛出 ConcurrentModificationException 异常。

示例程序

List<String> list = new ArrayList();
list.add("xiao");
list.add("peng");
list.add(".");

Iterator iterator = list.iterator();
while (iterator.hasNext()) {
    // 可能抛出 ConcurrentModificationException 异常
    iterator.next();
}

要实现线程安全有 3 种方式：

• 方法 1 - 使用 Vector 容器： Vector 是线程安全版本的数组容器，它会在所有方法上增加 synchronized 关键字（过时，了解即可）；
• 方法 2 - 使用 Collections.synchronizedList 包装类
• 方法 3 - 使用 CopyOnWriteArrayList 容器

Collections.synchronizedList 包装类的原理很简单，就是使用 synchronized 加锁，源码摘要如下：

Collections.java

public static <T> List<T> synchronizedList(List<T> list) {
    return (list instanceof RandomAccess ?
            new SynchronizedRandomAccessList<>(list) :
            new SynchronizedList<>(list));
}

// 使用 synchronized 实现线程安全
static class SynchronizedList<E> extends SynchronizedCollection<E> implements List<E> {
    final List<E> list;

    public boolean equals(Object o) {
        if (this == o) return true;
        synchronized (mutex) {return list.equals(o);}
    }
    public int hashCode() {
        synchronized (mutex) {return list.hashCode();}
    }

    public E get(int index) {
        synchronized (mutex) {return list.get(index);}
    }
    public E set(int index, E element) {
        synchronized (mutex) {return list.set(index, element);}
    }
    public void add(int index, E element) {
        synchronized (mutex) {list.add(index, element);}
    }
    public E remove(int index) {
        synchronized (mutex) {return list.remove(index);}
    }
		...
}

如果我们将 ArrayList 替换为 CopyOnWriteArrayList，即使其他线程并发修改数组，也不会抛出 ConcurrentModificationException 异常，这是为什么呢？

2. CopyOnWriteArrayList 的特点

CopyOnWriteArrayList 和 ArrayList 都是基于数组的动态数组，封装了操作数组时的搬运和扩容等逻辑。除此之外，CopyOnWriteArrayList 还是用了基于加锁的 “读写分离” 和 “写时复制” 的方案解决线程安全问题：

• 思想 1 - 读写分离（Read/Write Splitting）： 将对资源的读取和写入操作分离，使得读取和写入没有依赖，在 “读多写少” 的场景中能有效减少资源竞争；
• 思想 2 - 写时复制（CopyOnWrite，COW）： 在写入数据时，不直接在原数据上修改，而是复制一份新数据后写入到新数据，最后再替换到原数据的引用上。这个特性各有优缺点：
  • 优点 1 - 延迟处理： 在没有写入操作时不会复制 / 分配资源，能够避免瞬时的资源消耗。例如操作系统的 fork 操作也是一种写时复制的思想；
  • 优点 2 - 降低锁颗粒度： 在写的过程中，读操作不会被影响，读操作也不需要加锁，锁的颗粒度从整个列表降低为写操作；
  • 缺点 1 - 弱数据一致性： 在读的过程中，如果数据被其他线程修改，是无法实时感知到最新的数据变化的；
  • 缺点 2 - 有内存压力： 在写操作中需要复制原数组，在复制的过程中内存会同时存在两个数组对象（只是引用，数组元素的对象还是只有一份），会带来内存占用和垃圾回收的压力。如果是 “写多读少” 的场景，就不适合。

所以，使用 CopyOnWriteArrayList 的场景一定要保证是 “读多写少” 且数据量不大的场景，而且在写入数据的时候，要做到批量操作。否则每个写入操作都会触发一次复制，想想就可怕。举 2 个例子：

• 例如批量写入一组数据，要使用 addAll 方法 批量写入；
• 例如在做排序时，要先输出为 ArrayList，在 ArrayList 上完成排序后再写回 CopyOnWriteArrayList。

标签：系统,塔建,浏览器,请求服务,Spring 来源：

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。