JUC的CopyOnWriteArrayList怎么理解
这篇文章主要介绍"JUC的CopyOnWriteArrayList怎么理解"，在日常操作中，相信很多人在JUC的CopyOnWriteArrayList怎么理解问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答"JUC的CopyOnWriteArrayList怎么理解"的疑惑有所帮助！接下来，请跟着小编一起来学习吧！
CopyOnWriteArrayList 是线程安全的 List 实现，底层依赖于数组作为存储结构，并基于 写时复制（CoW: Copy-on-Write）机制 保证线程安全性。CopyOnWriteArrayList 在执行修改操作时会将底层数组复制一份，并在副本上实施修改，最后再更新回底层数组。虽然这样的实现比较消耗内存，但却带来了较高的执行效率，属于拿空间换时间。
除了 CopyOnWriteArrayList，在 JUC 包中还有另外一个基于 CoW 机制实现的线程安全组件，即 CopyOnWriteArraySet，不过 CopyOnWriteArraySet 本质上还是基于 CopyOnWriteArrayList 实现的，所以理解了 CopyOnWriteArrayList 的实现原理，也就同时理解了 CopyOnWriteArraySet 的实现原理。
CopyOnWriteArrayList 实现内幕
CopyOnWriteArrayList 实现自 List 接口，所以我们可以像使用 ArrayList 一样使用 CopyOnWriteArrayList。CopyOnWriteArrayList 类的字段定义如下：
public class CopyOnWriteArrayListimplements List , RandomAccess, Cloneable, Serializable { /** 支撑同步操作的重入锁 */ final transient ReentrantLock lock = new ReentrantLock(); /** 底层数组 */ private transient volatile Object[] array; // ... 省略方法定义}
其中 CopyOnWriteArrayList#array 数组是 CopyOnWriteArrayList 的底层存储结构，CopyOnWriteArrayList 依赖于该数组对数据进行存储。字段 CopyOnWriteArrayList#lock 对应 ReentrantLock 类型，用于控制多个线程对底层数组的修改操作，保证同一时间只有一个线程对底层数组进行修改。CopyOnWriteArrayList 提供了相应的 CopyOnWriteArrayList#getArray 和 CopyOnWriteArrayList#setArray 方法用于访问该字段。
CopyOnWriteArrayList 定义了多个重载的构造方法来初始化构造一个 CopyOnWriteArrayList 对象，实现上比较简单。下面重点看一下 CopyOnWriteArrayList 之于 List 接口中声明的核心方法实现，即增（add）、删（remove）、改（set）、查（get）操作。
首先来看一下 添加元素 的操作，CopyOnWriteArrayList 定义了多个重载版本的 CopyOnWriteArrayList#add 的方法实现，包括：
CopyOnWriteArrayList#add(E)CopyOnWriteArrayList#add(int, E)CopyOnWriteArrayList#addIfAbsent(E)CopyOnWriteArrayList#addAll(Collection)CopyOnWriteArrayList#addAll(int, Collection)CopyOnWriteArrayList#addAllAbsent
这些方法在实现上思想都是相通的，下面以 CopyOnWriteArrayList#add(E) 方法为例分析往 CopyOnWriteArrayList 中添加元素的运行机制，方法实现如下：
public boolean add(E e) { final ReentrantLock lock = this.lock; // 加锁，保证同一时间只有一个线程修改底层数组 lock.lock(); try { // 获取底层数组 Object[] elements = this.getArray(); int len = elements.length; // 复制出一份新的数组，长度加 1，以容纳待添加的元素 Object[] newElements = Arrays.copyOf(elements, len + 1); newElements[len] = e; // 更新底层数组 this.setArray(newElements); return true; } finally { // 释放锁 lock.unlock(); }}前面我们已经提及到 CopyOnWriteArrayList 对于数据的修改都是在副本上进行的，上述方法的实现印证了这一点。当往 CopyOnWriteArrayList 中添加一个元素时，方法的执行流程如下：
获取锁对象，保证同一时间只有一个线程在执行修改操作；
获取底层数组，基于该数组拷贝出一个新的数组，新数组长度加 1；
追加待添加元素到新数组的末尾位置，并更新底层数组；
释放锁对象。
再来看一下 获取元素 的操作，CopyOnWriteArrayList 仅定义了一个 CopyOnWriteArrayList#get 方法，用于获取指定下标的元素值，实现如下：
public E get(int index) { // 直接返回底层数组 index 下标的元素 return this.get(this.getArray(), index);}private E get(Object[] a, int index) { return (E) a[index];}实现上比较简单，这里主要强调一下弱一致性问题，也就说 get 操作不一定能够返回最新的值。考虑这样一个场景，假设有线程 A 和 B，其中 A 调用 get 方法获取数据，B 调用 add 方法添加数据，当前数组长度为 5：
线程 B 获取底层数组 x，然后拷贝出一个长度为 6 的新数组 y，并将待追加的元素设置到
y[5]的位置，此时还未更新底层数组；因为读操作无需获取锁，如果此时线程 A 尝试获取下标为 5 的元素，则会抛出 IndexOutOfBoundsException，因为此时 A 获取到的底层数组还是 x，还没有更新成 y。
然而，大部分时候这种弱一致性并不会对我们的业务造成影响，但是我们需要知道其存在，以便在发生错误时快速定位问题。
继续来看一下 修改元素 的操作，CopyOnWriteArrayList 同样仅定义了一个 CopyOnWriteArrayList#set 方法，用于修改指定下标的元素值，实现如下：
public E set(int index, E element) { final ReentrantLock lock = this.lock; // 获取锁 lock.lock(); try { // 获取底层数组 Object[] elements = this.getArray(); // 获取数组 index 下标值 E oldValue = this.get(elements, index); // 待更新的元素值与数组中指定位置的元素值不同 if (oldValue != element) { int len = elements.length; Object[] newElements = Arrays.copyOf(elements, len); // 更新 index 位置的元素值 newElements[index] = element; // 更新底层数组 this.setArray(newElements); } else { // Not quite a no-op; ensures volatile write semantics // 待更新的元素值与数组中指定位置的元素值相同，无需执行更新操作 this.setArray(elements); // 保证 volatile 写语义 } return oldValue; } finally { // 释放锁 lock.unlock(); }}上述方法的执行逻辑如代码注释，比较简单，但是当修改的目标元素值前后未发生变化时还是会调用 CopyOnWriteArrayList#setArray 方法更新一下底层数组，用意何在呢？
代码中给出的理由是 "Not quite a no-op; ensures volatile write semantics"，也就是说这里的更新操作不完全是一个无意义的操作，可以用来保证 volatile 的写语义，因为底层数组 array 是 volatile 类型。要理解其用意，可以参考 《深入理解 java 内存模型》一书中的示例（稍作修改）：
private int a = 0;private volatile boolean flag = true;public void writer() { a = 1; // 1 flag = true; // 2}public void reader() { if (flag) { // 3 int i = a; // 4 }}假设线程 A 执行 writer 方法之后，线程 B 执行 reader 方法。根据 happens-before 原则，这个过程建立的 happens-before 关系为：
根据程序次序规则，1 happens before 2; 3 happens before 4。
根据 volatile 规则，2 happens before 3。
根据 happens before 的传递性规则，1 happens before 4。
这样就能保证线程 B 在 reader 方法中读取 a 变量时能够看见线程 A 在 writer 方法中对 a 的修改，即使在 writer 方法中对变量 flag 的修改同样看似多余。
最后来看一下 删除元素 的操作，CopyOnWriteArrayList 针对删除操作定义了多个重载版本的 CopyOnWriteArrayList#remove 的方法实现，包括：
CopyOnWriteArrayList#remove(int)CopyOnWriteArrayList#remove(java.lang.Object)CopyOnWriteArrayList#removeAllCopyOnWriteArrayList#removeIf
下面以 CopyOnWriteArrayList#remove(int) 方法为例分析从 CopyOnWriteArrayList 中删除元素的运行机制，方法实现如下：
public E remove(int index) { final ReentrantLock lock = this.lock; // 获取锁 lock.lock(); try { // 获取底层数组 Object[] elements = this.getArray(); int len = elements.length; // 获取指定下标元素 E oldValue = this.get(elements, index); int numMoved = len - index - 1; // 如果是删除最后一个元素，则直接 copy 即可，无需移动 if (numMoved == 0) { this.setArray(Arrays.copyOf(elements, len - 1)); } else { // 否则，分两次进行拷贝，去掉原 index 下标的元素 Object[] newElements = new Object[len - 1]; System.arraycopy(elements, 0, newElements, 0, index); System.arraycopy(elements, index + 1, newElements, index, numMoved); this.setArray(newElements); } return oldValue; } finally { // 释放锁 lock.unlock(); }}删除的逻辑本质上还是在副本上进行，如上述代码注释，其过程与前面分析的操作类似。
除了上面分析的核心操作方法，CopyOnWriteArrayList 还实现了 CopyOnWriteArrayList#iterator 方法返回一个迭代器，实现如下：
public Iteratoriterator() { return new COWIterator (this.getArray(), 0);}
关于 COWIterator 的实现不再继续深入，但是需要知晓的一点是，COWIterator 不支持在迭代过程中修改 CopyOnWriteArrayList 中的元素，对应的 COWIterator#remove、COWIterator#set 和 COWIterator#add 方法均直接抛出 UnsupportedOperationException 异常。此外，方法 CopyOnWriteArrayList#iterator 返回的是一个弱一致性迭代器，即在迭代期间，其它线程对于底层数组的修改并不会被迭代器看见。
到此，关于"JUC的CopyOnWriteArrayList怎么理解"的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注网站，小编会继续努力为大家带来更多实用的文章！
