我们肯定都使用过ArrayList，但是多线程或并发环境下，ArrayList作为共享变量被访问，是线程不安全的。我们可以选择自己加锁或Collections.synchronizedList()去实现一个线程安全的容器。除此之外，我们还可以使用今天要学习的CopyOnWriteArrayList。
CopyOnWrite：
是一种策略，表示在使用的时候，将共享内容拷贝一份进行修改，修改完成之后，然后将原容器指向修改后的内容，保证的是最终一致性，因为读写是不同的容器，读的时候不加锁，写的时候加锁。JDK中有CopyOnWriteArrayList和CopyOnWriteArraySet两种已经实现的容器，了解这种思想，我们甚至可以自定义实现别的容器，例如Map，但是为什么没有实现CopyOnWriteHashMap呢，因为已经有了优秀的ConcurrentHashMap。
类注释：
从类注释我们可以得到以下信息：
- CopyOnWriteArrayList是ArrayList的安全变体。
- CopyOnWriteArrayList的实现需要数组拷贝有一定的成本，但是通过比其他的方案效率更高。
- 允许存放各种元素，包括null。
- 迭代过程中，进行修改不会出现ConcurrentModificationException，因为读写分离。
类属性：
public class CopyOnWriteArrayList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
private static final long serialVersionUID = 8673264195747942595L;
final transient ReentrantLock lock = new ReentrantLock();
private transient volatile Object[] array;
final Object[] getArray() {
return array;
}
final void setArray(Object[] a) {
array = a;
}
public CopyOnWriteArrayList() {
setArray(new Object[0]);
}
public CopyOnWriteArrayList(Collection<? extends E> c) {
Object[] elements;
if (c.getClass() == CopyOnWriteArrayList.class)
elements = ((CopyOnWriteArrayList<?>)c).getArray();
else {
elements = c.toArray();
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elements.getClass() != Object[].class)
elements = Arrays.copyOf(elements, elements.length, Object[].class);
}
setArray(elements);
}
public CopyOnWriteArrayList(E[] toCopyIn) {
setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
}
}
从上面的代码可以得到以下信息：
- CopyOnWriteArrayList有一个ReentrantLock实现的锁。
- 和ArrayList一样，都是通过数组保存数据，但是多个volatile的修饰，用来满足Happen-Before原则。
- 默认构造函数，将数组初始化为1，没有设置数组大小的构造函数，只能讲数组或者容器传入。
添加
public void add(int index, E element) {
final ReentrantLock lock = this.lock;
//通过ReentrantLock加锁
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;
//如果直接插入到尾部，直接使用copyOf复制一个新的数组，length+1
if (numMoved == 0)
newElements = Arrays.copyOf(elements, len + 1);
else {
//直接初始化一个新的数组，长度+1
newElements = new Object[len + 1];
//复制index前面的部分到新数组
System.arraycopy(elements, 0, newElements, 0, index);
//复制index后面的部分到新数组的相应位置
System.arraycopy(elements, index, newElements, index + 1,
numMoved);
}
//对index位置赋值
newElements[index] = element;
//设置到数组中
setArray(newElements);
} finally {
//解锁
lock.unlock();
}
}
这里选择了插入对应下标的方法，如果是插入到尾部，更加简单，可以自行查看。和ArrayList的相关源码差不多，除了加锁解锁，就是ArrayList是直接对原数组进行修改，而CopyOnWriteArrayList选择生成一个新的数组，先将elements的index前面部分复制过去，然后复制后面的部分，然后将element赋值，整体代码非常简单明了。
System.arraycopy()
参数分别为：原数组，复制的起始下标，新数组，复制到新数组原则的起始下标，复制的长度。
获取
public E get(int index) {
return get(getArray(), index);
}
private E get(Object[] a, int index) {
return (E) a[index];
}
get()没啥好讲的，就是从数组中获取，可以看到没有通过锁进行加密，读的时候不进行加锁，很有可能出现读到旧数据的情况。
删除
public E remove(int index) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
E oldValue = get(elements, index);
int numMoved = len - index - 1;
if (numMoved == 0)
setArray(Arrays.copyOf(elements, len - 1));
else {
Object[] newElements = new Object[len - 1];
System.arraycopy(elements, 0, newElements, 0, index);
System.arraycopy(elements, index + 1, newElements, index,
numMoved);
setArray(newElements);
}
return oldValue;
} finally {
lock.unlock();
}
}
步骤如下：
- 加锁。
- 通过下标获取oldValue。
- 如果index为最后一位，直接复制数据，长度-1.
- 如果index不是最后一位，生成一个新数组，然后先复制index前面的部分，然后index后面的数据整体迁移一位。
- 解锁。
修改
public E set(int index, E element) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
E oldValue = get(elements, index);
if (oldValue != element) {
int len = elements.length;
Object[] newElements = Arrays.copyOf(elements, len);
newElements[index] = element;
setArray(newElements);
} else {
// Not quite a no-op; ensures volatile write semantics
setArray(elements);
}
return oldValue;
} finally {
lock.unlock();
}
}
步骤如下：
- 加锁。
- 通过参数下标获取oldValue。
- 如果oldValue和参数element不等，生成一个新数组，然后直接替换index位置的数据，setArray()。
- 否则setArray()，这一步没看太懂，看了上面的注释，确保volatile的写语义。
- 返回oldValue，解锁。
批量删除
public boolean removeAll(Collection<?> c) {
if (c == null) throw new NullPointerException();
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
if (len != 0) {
int newlen = 0;
Object[] temp = new Object[len];
for (int i = 0; i < len; ++i) {
Object element = elements[i];
if (!c.contains(element))
temp[newlen++] = element;
}
if (newlen != len) {
setArray(Arrays.copyOf(temp, newlen));
return true;
}
}
return false;
} finally {
lock.unlock();
}
}
步骤如下：
- 加锁。
- 当前数组为空，返回false，否则继续。
- 定义变量newlen，和一个长度为len的空数组，遍历elements数组，判断要删除的collection中是否当前下标值，如果不包含保存到temp数组。
- 如果newlen != len，复制一个长度为newlen的数组，setArray()，佛足额返回false。
- 解锁。
从上面我们看到批量删除并不是遍历然后删除每个元素，因为删除元素每次都会有一次数组拷贝，这样会很消耗性能，加锁时间变得很长，影响并发，所以这是批量删除更好的思路，将不需要删除的元素都放到新数组中，而不是挨个删除。
关于迭代：
CopyOnWriteArrayList通过COWIterator实现的迭代器，每次迭代，持有的是原数组的引用，所以修改和新增不会影响到迭代。
总结：
通过上面的源码，我们队CopyOnWriteArrayList有了基本的了解，由于读的时候不加锁，而synchronizedList读写都是加锁的，所以相对来说还是比较推荐使用前者，在并发多线程的场景下。