目录
一.写时复制介绍
3.1 重要属性
3.3 构造方法
3.4 获取元素
3.5 添加元素
3.5.1 追加元素
3.5.2 指定位置插入元素
3.6 删除元素
3.6.1 删除指定位置的元素
3.6.2 删除指定元素
3.7 修改元素
3.8 元素增删改查的总结
四.总结
一.写时复制介绍
写时复制（copy on write），具体的介绍可以查看百度百科-写时复制，这里就举一个简单的例子来介绍写时复制是什么样的。
有一份大家共享的文档，所有都可以查看、编辑这份文档；
小A和小B想要查看文档，那么他们俩可以将这份文档复印一份（人手一份），但是为了节约纸张和钱，他们俩就决定不复印文档了，两人先将就一下，一起查阅这份文档吧（共享）；
在小A和小B正在查看文档的过程中，小C想要修改文档，而修改文档的话，就会影响他们俩查看文档，于是小C就将文档复制了一份，将原件给小A和小B继续查阅文档（不影响他们俩），而小C就可以在复印的文档上进行修改了；
小C将文档修改完后，就将文档放回存放文档的地方；
而小A和小B正在查看的那份文档就没有意义了（等待小A和小B阅读后，就可以销毁了）；
小A和小B下一次再想看文档时，就拿到的是经过小C修改过后的文档了。
理解了上面这个过程，也就理解了“写时复制”的原理了。
原文地址：https://www.cnblogs.com/-beyond/p/13130040.html
二.CopyOnWriteArrayList介绍
Java中的ArrayList是一个非线程安全的集合类，也就是说，当多个线程对ArrayList进行并发读写时，就可能会出现问题。
虽然可以使用Vector来保证同步操作，解决线程安全问题，但是由于Vector只是简单的在接口上加synchronized关键字进行同步，即使synchronized已经做了很多优化（性能极大地提升），但是Vector中在方法级别加synchronized，同步的代码区域太大，吞吐量并不会太高。
CopyOnWriteArrayList，就是线程安全版的ArrayList，可以支持多线程并发修改获取数组元素，利用的就是上面写时复制的原理。
三.CopyOnWriteArrayList源码解析
3.1 重要属性
/** * 用于加锁（可重入，默认为非公平锁） */ final transient ReentrantLock lock = new ReentrantLock(); /** * 保存数据的数组 */ private transient volatile Object[] array;
对的，CopyOnWriteArrayList就只有上面两个属性，比ArrayList少了很多，ArrayList中初始容量、扩容阈值、树化阈值、负载因子....
随着后面对源码的学习，就会知道CopyOnWriteArrayList中的数组（也就是array），每次都是毫不浪费，刚好装下所有元素（其实是每次添加元素的时候则增加一个位置，删除元素后就释放一个位置，所以数组的长度始终和元素的个数相同）。
3.2 getArray和setArray
CopyOnWriteArrayList中有两个私有的方法，用来获取和设置array属性值，几乎贯穿CopyOnWriteArrayList整个源码。
/**
* 获取当前的数组
*/
final Object[] getArray() {
return array;
}
/**
* 将传入的数组替换掉已有的数组（修改数据后替换掉旧数组）
*/
final void setArray(Object[] a) {
array = a;
}
3.3 构造方法
/**
* 创建一个空数组的CopyOnWriteArrayList实例
*/
public CopyOnWriteArrayList() {
setArray(new Object[0]);
}
/**
* 利用已有的集合元素创建CopyOnWriteArrayList实例
*/
public CopyOnWriteArrayList(Collection<? extends E> c) {
Object[] elements; // 副本
if (c.getClass() == CopyOnWriteArrayList.class) {
elements = ((CopyOnWriteArrayList<?>) c).getArray();
} else {
// 将传入的集合转为数组形式
elements = c.toArray();
if (elements.getClass() != Object[].class) {
elements = Arrays.copyOf(elements, elements.length, Object[].class);
}
}
// 将array属性设置指向本次创建的副本
setArray(elements);
}
/**
* 利用传入的数组来创建CopyOnWriteArrayList实例
*/
public CopyOnWriteArrayList(E[] toCopyIn) {
setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
}
3.4 获取元素
获取元素，和ArrayList接口一样，都是get(index)，但是需要注意的是，CopyOnWriteArrayList在get元素的时候并不做数组越界检测。
/**
* 获取数组index位置的元素
*/
public E get(int index) {
// 先调用getArray获取数组，然后调用内部的get方法进行返回元素
return get(getArray(), index);
}
/**
* 获取指定数组的指定位置元素
*/
private E get(Object[] a, int index) {
return (E) a[index];
}
3.5 添加元素
3.5.1 追加元素
/**
* 追加元素到集合中
*/
public boolean add(E e) {
final ReentrantLock lock = this.lock;
// 先尝试获取锁，未获取到锁则阻塞
lock.lock();
try {
// 获取数组
Object[] elements = getArray();
int len = elements.length;
// 创建一个新的数组（新数组长度比旧数组长度大1）
Object[] newElements = Arrays.copyOf(elements, len + 1);
// 将元素追加到最后新多出来的一个位置（最后）
newElements[len] = e;
// 将新数组替换掉旧数组
setArray(newElements);
return true;
} finally {
// 释放锁
lock.unlock();
}
}
3.5.2 指定位置插入元素
/**
* 在指定位置插入元素
*/
public void add(int index, E element) {
final ReentrantLock lock = this.lock;
// 加锁
lock.lock();
try {
// 获取当前数组和数组长度
Object[] elements = getArray();
int len = elements.length;
// 插入位置越界检测
if (index > len || index < 0) {
throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + len);
}
// 计算需要移动的元素个数
Object[] newElements;
int numMoved = len - index;
if (numMoved == 0) {
// 需要移动元素的个数为0，表示追加（直接申请len+1长度的数组）
newElements = Arrays.copyOf(elements, len + 1);
} else {
// 有元素需要移动，先申请len+1长度的数组
newElements = new Object[len + 1];
// 将旧数组中0 - index-1元素拷贝到新数组中
System.arraycopy(elements, 0, newElements, 0, index);
// 将旧数组中index以及后面的元素拷贝到新数组中（index位置空余）
System.arraycopy(elements, index, newElements, index + 1, numMoved);
}
// 将新元素放入空出的index位置
newElements[index] = element;
// 新数组替换掉旧数组
setArray(newElements);
} finally {
// 解锁
lock.unlock();
}
}
3.6 删除元素
3.6.1 删除指定位置的元素
/**
* 删除指定位置的元素
*/
public E remove(int index) {
final ReentrantLock lock = this.lock;
// 加锁
lock.lock();
try {
// 获取当前最新的数组
Object[] elements = getArray();
int len = elements.length;
// 获取index位置的元素（要删除的元素）
E oldValue = get(elements, index);
// 计算要移动的元素
int numMoved = len - index - 1;
if (numMoved == 0) {
// 如果要移动的元素为0，证明删除的最后一个元素
// 则直接创建一个新数组（长度为len-1），并将前len-1个元素拷贝到新数组中，并替换掉旧数组
setArray(Arrays.copyOf(elements, len - 1));
} else {
// 删除的元素不是在最后，那么就申请len-1长度的数组
Object[] newElements = new Object[len - 1];
// 将0~len-1和len+1~end的元素拷贝到新数组中
System.arraycopy(elements, 0, newElements, 0, index);
System.arraycopy(elements, index + 1, newElements, index, numMoved);
// 替换掉旧数组
setArray(newElements);
}
// 返回删除的元素
return oldValue;
} finally {
// 解锁
lock.unlock();
}
}
3.6.2 删除指定元素
/**
* 删除元素（删除成功范围true，未找到或者删除失败返回false）
*/
public boolean remove(Object o) {
// 获取当前数组
Object[] snapshot = getArray();
// 在数组中查找要删除的元素
int index = indexOf(o, snapshot, 0, snapshot.length);
// index<0，表示未找到元素；否则进行删除元素
return (index < 0) ? false : remove(o, snapshot, index);
}
/**
* 在elements数组中的index到fence范围内查找元素o
*
* @param o 要查找的元素
* @param elements 在该数组中查找
* @param index 查找的其实位置
* @param fence 屏障（查找结束的位置）
* @return 如果查找到元素，则返回元素所在位置；如果没有查找到，则返回-1
*/
private static int indexOf(Object o, Object[] elements, int index, int fence) {
// 使用循环进行遍历数组，从头到尾找到第一个匹配的元素位置
if (o == null) {
for (int i = index; i < fence; i++) {
if (elements[i] == null) {
return i;
}
}
} else {
for (int i = index; i < fence; i++) {
if (o.equals(elements[i])) {
return i;
}
}
}
// 未找到元素，则返回-1
return -1;
}
/**
* 删除snapshot数组中index位置的元素o
* 不是直接删除快照数组中的index位置的元素，而是经过一番比较，确定要删除的元素的真实位置
* 然后在申请一个新数组，将index以外的其他元素拷贝到新数组中，并替换新数组，以此达到删除的效果
*/
private boolean remove(Object o, Object[] snapshot, int index) {
final ReentrantLock lock = this.lock;
// 获取锁
lock.lock();
try {
// 获取数组
Object[] current = getArray();
int len = current.length;
// 如果传入的数组快照和当前的最新数组不匹配（发生了增删）
if (snapshot != current) findIndex:{
// 获取新数组的长度，与传入的index进行比较（确定查找范围，以小者为准）
int prefix = Math.min(index, len);
// 遍历数组，
for (int i = 0; i < prefix; i++) {
// 如果数组快照和新数组的元素不匹配，并且最新数组的该位置上的元素就是要删除的元素
// 此时修改要index（改为要删除元素当前的最新位置），并结束循环
if (current[i] != snapshot[i] && eq(o, current[i])) {
index = i;
break findIndex;
}
}
// 如果新数组的长度小于传入的要删除元素的index，则证明未找到该元素
if (index >= len) {
return false;
}
// 如果当前数组的index位置为要删除的元素（找到要删除的元素位置），则跳出if
if (current[index] == o) {
break findIndex;
}
// 在最新数组中查找要删除的元素，如果最新数组未找到要删除的元素，则删除失败，返回false
index = indexOf(o, current, index, len);
if (index < 0) {
return false;
}
}
// 当前最新的数组为len，因为找到了要删除的元素，则申请一个新的数组（长度为len-1）
Object[] newElements = new Object[len - 1];
// 将当前最新的数据，0~index-1的元素拷贝到新数组中
System.arraycopy(current, 0, newElements, 0, index);
// 将当前最新的数据，index+1及后面的数据拷贝到新数组中
System.arraycopy(current, index + 1, newElements, index, len - index - 1);
// 使用新数组替换掉旧数组，因为删除了元素，所以返回true
setArray(newElements);
return true;
} finally {
// 解锁
lock.unlock();
}
}
3.7 修改元素
/**
* 修改index位置的元素，设置为element，并返回旧值
*/
public E set(int index, E element) {
final ReentrantLock lock = this.lock;
// 获取锁
lock.lock();
try {
// 获取旧数组中index位置的值
Object[] elements = getArray();
E oldValue = get(elements, index);
// 如果index位置的值和要修改的值不相同，那需要进行修改操作
if (oldValue != element) {
// 获取当前数组的长度
int len = elements.length;
// 创建一个新数组（新数组长度和旧数组长度保持一致），并将旧数组中全部元素拷贝到新数组中
Object[] newElements = Arrays.copyOf(elements, len);
// 修改新数组中的index位置的元素
newElements[index] = element;
// 新数组替换掉旧数组
setArray(newElements);
} else {
// 如果index位置的值和要修改的值相同，那么不用进行修改操作（避免申请数组、拷贝的开销）
setArray(elements);
}
// 返回旧值
return oldValue;
} finally {
lock.unlock();
}
}
3.7 元素增删改的总结
上面在添加元素、删除元素、修改元素中，可以看到，CopyOnWriteArrayList每次进行写操作的时候，都是这样一个步骤：
1.加锁；
2.获取当前数组（snapshot快照）；
3.创建新数组，然后在新数组中进行修改操作；
4.将修改完后的新数组替换掉snapshot快照数组；
5.解锁。
需要注意的是，当一个线程A在遍历CopyOnWriteArrayList时，当另外一个线程B对CopyOnWriteArrayList进行了修改操作，线程B修改完成后（已经将新数组替换掉旧数组），但是线程A查看的仍旧是旧的数组（snapshot），除非重新获取数组。
四.总结
CopyOnWriteArrayList的源码也挺简单的，但是需要注意的是，CopyOnWriteArrayList最好用在读多写少的场景，从前面介绍的源码中，可以看到每次修改操作，都会进行加锁、申请新数组和拷贝复制，如果频繁修改，则可能造成系统资源浪费和效率降低（频繁申请数组，可能会触发GC）。
原文地址：https://www.cnblogs.com/-beyond/p/13130040.html