阅读完需：约 9 分钟
CopyOnWriteArrayList:CopyOnWriteArrayList这是一个ArrayList的线程安全的变体，其原理大概可以通俗的理解为:初始化的时候只有一个容器，很常一段时间，这个容器数据、数量等没有发生变化的时候，大家(多个线程)，都是读取(假设这段时间里只发生读取的操作)同一个容器中的数据，所以这样大家读到的数据都是唯一、一致、安全的，但是后来有人往里面增加了一个数据，这个时候CopyOnWriteArrayList 底层实现添加的原理是先copy出一个容器(可以简称副本)，再往新的容器里添加这个新的数据，最后把新的容器的引用地址赋值给了之前那个旧的的容器地址，但是在添加这个数据的期间，其他线程如果要去读取数据，仍然是读取到旧的容器里的数据。
java的线程安全除了 CopysOnWriteArrayList 还有 Vector 。
注：源码是 OpenJDK 14
01、Vector
Vector 的源码文档上直截了当地说了，“如果不需要线程安全，推荐使用 ArrayList 替代 Vector。”因为它的线程安全是建立在每个方法上都加了 synchronized 关键字的基础上，锁的粒度很高，意味着性能就不咋滴。
public synchronized boolean add(E e) {
modCount++;
add(e, elementData, elementCount);
return true;
}
public synchronized E remove(int index) {
modCount++;
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
E oldValue = elementData(index);
int numMoved = elementCount - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--elementCount] = null; // Let gc do its work
return oldValue;
}就连 size() 这样的方法上都加了 synchronized，可想而知，Vector 有多铺张浪费，有多锦衣玉食。
02、SynchronizedList
可以使用 Collections.synchronizedList() 让 ArrayList 变成线程安全啊。
public static <T> List<T> synchronizedList(List<T> list) {
return (list instanceof RandomAccess ?
new Collections.SynchronizedRandomAccessList<>(list) :
new Collections.SynchronizedList<>(list));
}无论是 SynchronizedRandomAccessList 还是 SynchronizedList，它们都没有在方法级别上使用 synchronized 关键字，而是在方法体内使用了 synchronized(this) 块。
public void add(int index, E element) {
synchronized (mutex) {list.add(index, element);}
}
public E remove(int index) {
synchronized (mutex) {return list.remove(index);}
}其中 mutex 为 this 关键字，也就是当前对象。
final Object mutex; // Object on which to synchronize
SynchronizedCollection(Collection<E> c) {
this.c = Objects.requireNonNull(c);
mutex = this;
}03、ConcurrentModificationException
ConcurrentModificationException 这个异常不知道有没有遇到过？先来敲段代码让它发生一次。
List<String> list = new ArrayList<>();
list.add("王二");
list.add("王三");
list.add("程序员");
for (String str : list) {
if ("王二".equals(str)) {
list.remove(str);
}
}
System.out.println(list);运行这段代码就会抛出 ConcurrentModificationException：
Exception in thread "main" java.util.ConcurrentModificationException
at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:1012)
at java.base/java.util.ArrayList$Itr.next(ArrayList.java:966)通过异常的堆栈信息可以查找到，异常发生在 ArrayList 的内部类 Itr 的 checkForComodification() 方法中。
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}也就是说，在执行 checkForComodification() 方法的时候，发现 modCount 和 expectedModCount 不等，就抛出了 ConcurrentModificationException 异常。
为什么会这样呢？之前的代码也没有调用 checkForComodification() 方法啊！
那就只能来看一下反编译后的字节码了，原来 for-each 这个语法糖是通过 Iterator 实现的。
List<String> list = new ArrayList();
list.add("王二");
list.add("王三");
list.add("程序员");
Iterator var3 = list.iterator();
while (var3.hasNext()) {
String str = (String) var3.next();
if ("王二".equals(str)) {
list.remove(str);
}
}
System.out.println(list); 在执行 list.iterator() 的时候，其实返回的就是 ArrayList 的内部类 Itr。
public Iterator<E> iterator() {
return new ArrayList.Itr();
}迭代器 Iterator 是 fail-fast 的，如果以任何方式（包括 remove 和
add）对迭代器进行修改的话，就会抛出 ConcurrentModificationException。
迭代器在执行 remove() 方法的时候，会对 modCount 加 1。remove() 方法内部会调用 fastRemove() 方法。
private void fastRemove(Object[] es, int i) {
modCount++;
final int newSize;
if ((newSize = size - 1) > i)
System.arraycopy(es, i + 1, es, i, newSize - i);
es[size = newSize] = null;
}当在进行下一次 next() 会执行 checkForComodification() 方法，结果发现 modCount 为 4，而 expectedModCount 为 3，于是就抛出了异常。
之所以在单线程的情况下就抛出 ConcurrentModificationException，就是为了在多线程并发的情况下，不冒任何的危险，提前规避掉其他线程对 List 修改的可能性。
ArrayList 返回的迭代器是 fail-fast 的，Vector 的也是，SynchronizedList 的也是。这就意味着它们在多线程环境下通过 for-each 遍历进行增删操作的时候会出问题。
04、CopyOnWriteArrayList
一切都是为了引出 CopyOnWriteArrayList
List<String> list = new CopyOnWriteArrayList();
list.add("王二");
list.add("王三");
list.add("程序员");
for (String str : list) {
if ("王二".equals(str)) {
list.remove(str);
}
}
System.out.println(list);把 ArrayList 换成 CopyOnWriteArrayList，程序就能够正常执行了，输出结果如下所示。
[王三, 程序员]之所以不抛出 ConcurrentModificationException 异常，是因为 CopyOnWriteArrayList 是 fail-safe 的，迭代器遍历的是原有的数组，remove 的时候 remove 的是复制后的新数组，然后再将新数组赋值给原有的数组。
不过，任何在获取迭代器之后对 CopyOnWriteArrayList 的修改将不会及时反映迭代器里。
CopyOnWriteArrayList<String> list1 =
new CopyOnWriteArrayList<>(new String[] {"王二", "王三"});
Iterator itr = list1.iterator();
list1.add("王四");
while(itr.hasNext()) {
System.out.print(itr.next() + " ");
}王四并不会出现在输出结果中。
王二 王三 ArrayList 的迭代器 Itr 是支持 remove 的
List<String> list = new ArrayList();
list.add("王二");
list.add("王三");
list.add("程序员");
Iterator var3 = list.iterator();
while (var3.hasNext()) {
String str = (String) var3.next();
if ("王二".equals(str)) {
var3.remove();
}
}
System.out.println(list);程序输出的结果如下所示：
[王三, 程序员]而 CopyOnWriteArrayList 的迭代器 COWIterator 是不支持 remove 的。
public void remove() {
throw new UnsupportedOperationException();
}
CopyOnWriteArrayList 实现了 List 接口，不过，它不在 java.util 包下，而在 java.util.concurrent 包下，算作是 ArrayList 的增强版，线程安全的。
顾名思义，CopyOnWriteArrayList 在进行写操作（add、set、remove）的时候会先进行拷贝，底层是通过数组复制来实现的。
Java 8 的时候，CopyOnWriteArrayList 的增删改操作方法使用的是 ReentrantLock（可重入锁，一个线程获得了锁之后仍然可以反复的加锁，不会出现自己阻塞自己的情况）。
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();
}
}Java 14 的时候，已经改成 synchronized 块了。
public boolean add(E e) {
synchronized (lock) {
Object[] es = getArray();
int len = es.length;
es = Arrays.copyOf(es, len + 1);
es[len] = e;
setArray(es);
return true;
}
}其中的 lock 是一个 Object 对象（注释上说和 ReentrantLock 有一点关系）。
/**
* The lock protecting all mutators. (We have a mild preference
* for builtin monitors over ReentrantLock when either will do.)
*/
final transient Object lock = new Object();Java 14 的写法比 Java 8 更简洁一些，其中就少了一个 newElements 变量的创建。
再来看 set() 方法：
public E set(int index, E element) {
synchronized (lock) {
Object[] es = getArray();
E oldValue = elementAt(es, index);
if (oldValue != element) {
es = es.clone();
es[index] = element;
}
// Ensure volatile write semantics even when oldvalue == element
setArray(es);
return oldValue;
}
}同样使用了 synchronized 块，并且调用了封装好的 clone() 方法进行了复制。
然后来看 remove() 方法：
public E remove(int index) {
synchronized (lock) {
Object[] es = getArray();
int len = es.length;
E oldValue = elementAt(es, index);
int numMoved = len - index - 1;
Object[] newElements;
if (numMoved == 0)
newElements = Arrays.copyOf(es, len - 1);
else {
newElements = new Object[len - 1];
System.arraycopy(es, 0, newElements, 0, index);
System.arraycopy(es, index + 1, newElements, index,
numMoved);
}
setArray(newElements);
return oldValue;
}
}synchronized 块是必须的，数组复制（System.arraycopy()）也是必须的。
和 Vector 不同的是，CopyOnWriteArrayList 的 get()、size() 方法不再加锁。
public int size() {
return getArray().length;
}
public E get(int index) {
return elementAt(getArray(), index);
}简单总结一下就是：第一，CopyOnWriteArrayList 在修改时，复制出一个新数组，修改的操作在新数组中完成，最后将新数组赋值给原有的数组引用。第二，CopyOnWriteArrayList 的写加锁，读不加锁。
CopyOnWriteArrayList 有很多优势，但数组复制是沉重的，如果写的操作比较多，而读的操作比较少，内存就会被占用得比较多；另外，CopyOnWriteArrayList 无法保证数据是实时同步的，因为读写操作是分离的，写的操作都建立在复制的新数组上，而读的是原有的数组。
