简介
CopyOnWriteArrayList是ArrayList的线程平安版本，外部也是通过数组实现，每次对数组的批改都齐全拷贝一份新的数组来批改，批改完了再替换掉老数组，这样保障了只阻塞写操作，不阻塞读操作，实现读写拆散。
继承体系
public class CopyOnWriteArrayList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {...}- CopyOnWriteArrayList实现了List，RandomAccess，Cloneable，java.io.Serializable等接口。
- CopyOnWriteArrayList实现了List，提供了根底的增加、删除、遍历等操作。
- CopyOnWriteArrayList实现了RandomAccess，提供了随机拜访的能力。
- CopyOnWriteArrayList实现了Cloneable，能够被克隆。
- CopyOnWriteArrayList实现了Serializable，能够被序列化。
源码解析
属性
/** 用于批改时加锁 */final transient ReentrantLock lock = new ReentrantLock();/** 真正存储元素的中央，只能通过getArray()/setArray()拜访 */private transient volatile Object[] array;- lock：批改时加锁，应用transient润饰示意不主动序列化。
- array：存储元素的中央，应用transient润饰示意不主动序列化，应用volatile润饰示意一个线程对这个字段的批改另外一个线程立刻可见。
构造方法
创立空数组。
public CopyOnWriteArrayList() { // 所有对array的操作都是通过setArray()和getArray()进行 setArray(new Object[0]);}final void setArray(Object[] a) { array = a;}public CopyOnWriteArrayList(Collection<? extends E> c) { Object[] elements; if (c.getClass() == CopyOnWriteArrayList.class) // 如果c也是CopyOnWriteArrayList类型 // 那么间接把它的数组拿过去应用 elements = ((CopyOnWriteArrayList<?>)c).getArray(); else { // 否则调用其toArray()办法将汇合元素转化为数组 elements = c.toArray(); // 这里c.toArray()返回的不肯定是Object[]类型 // 具体起因见ArrayList外面的剖析 if (elements.getClass() != Object[].class) elements = Arrays.copyOf(elements, elements.length, Object[].class); } setArray(elements);}- 如果 c 是CopyOnWriteArrayList类型，间接把它的数组赋值给以后list的数组，留神这里是浅拷贝，两个汇合共用同一个数组。
- 如果 c 不是CopyOnWriteArrayList类型，则进行拷贝把c的元素全副拷贝到以后list的数组中。
public CopyOnWriteArrayList(E[] toCopyIn) { setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));}- 把toCopyIn的元素拷贝给以后list的数组。
add(E e)办法
增加一个元素到开端。
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(); }}- 加锁；
- 获取元素数组；
- 新建一个数组，大小为原数组长度加1，并把原数组元素拷贝到新数组；
- 把新增加的元素放到新数组的开端；
- 把新数组赋值给以后对象的array属性，笼罩原数组；
- 解锁。
add(int index, E element)办法
增加一个元素在指定索引处。
public void add(int index, E element) { final ReentrantLock lock = this.lock; // 加锁 lock.lock(); try { // 获取旧数组 Object[] elements = getArray(); int len = elements.length; // 查看是否越界, 能够等于len if (index > len || index < 0) throw new IndexOutOfBoundsException("Index: "+index+ ", Size: "+len); Object[] newElements; int numMoved = len - index; if (numMoved == 0) // 如果插入的地位是最初一位 // 那么拷贝一个n+1的数组, 其前n个元素与旧数组统一 newElements = Arrays.copyOf(elements, len + 1); else { // 如果插入的地位不是最初一位 // 那么新建一个n+1的数组 newElements = new Object[len + 1]; // 拷贝旧数组前index的元素到新数组中 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(); }}- 加锁；
- 查看索引是否非法，如果不非法抛出
IndexOutOfBoundsException异样，留神这里 index 等于 len 也是非法的； - 如果索引等于数组长度（也就是数组最初一位再加1），那就拷贝一个
len+1的数组； - 如果索引不等于数组长度，那就新建一个
len+1的数组，并按索引地位分成两局部，索引之前（不蕴含）的局部拷贝到新数组索引之前（不蕴含）的局部，索引之后（蕴含）的地位拷贝到新数组索引之后（不蕴含）的地位，索引所在位置留空； - 把索引地位赋值为待增加的元素；
- 把新数组赋值给以后对象的array属性，笼罩原数组；
- 解锁；
addIfAbsent(E e)办法
增加一个元素如果这个元素不存在于汇合中。
public boolean addIfAbsent(E e) { // 获取元素数组, 取名为快照 Object[] snapshot = getArray(); // 查看如果元素不存在,间接返回false // 如果存在再调用addIfAbsent()办法增加元素 return indexOf(e, snapshot, 0, snapshot.length) >= 0 ? false : addIfAbsent(e, snapshot);}private boolean addIfAbsent(E e, Object[] snapshot) { final ReentrantLock lock = this.lock; // 加锁 lock.lock(); try { // 从新获取旧数组 Object[] current = getArray(); int len = current.length; // 如果快照与刚获取的数组不统一 // 阐明有批改 if (snapshot != current) { // 从新查看元素是否在刚获取的数组里 int common = Math.min(snapshot.length, len); for (int i = 0; i < common; i++) // 到这个办法外面了, 阐明元素不在快照外面 if (current[i] != snapshot[i] && eq(e, current[i])) return false; if (indexOf(e, current, common, len) >= 0) return false; } // 拷贝一份n+1的数组 Object[] newElements = Arrays.copyOf(current, len + 1); // 将元素放在最初一位 newElements[len] = e; setArray(newElements); return true; } finally { // 开释锁 lock.unlock(); }}- 查看这个元素是否存在于数组快照中；
- 如果存在间接返回 false，如果不存在调用
addIfAbsent(E e, Object[] snapshot)解决; - 加锁；
- 如果以后数组不等于传入的快照，阐明有批改，查看待增加的元素是否存在于以后数组中，如果存在间接返回false;
- 拷贝一个新数组，长度等于原数组长度加1，并把原数组元素拷贝到新数组中；
- 把新元素增加到数组最初一位；
- 把新数组赋值给以后对象的array属性，笼罩原数组；
- 解锁；
get(int index)
获取指定索引的元素，反对随机拜访，工夫复杂度为O(1)。
public E get(int index) { // 获取元素不须要加锁 // 间接返回index地位的元素 // 这里是没有做越界查看的, 因为数组自身会做越界查看 return get(getArray(), index);}final Object[] getArray() { return array;}private E get(Object[] a, int index) { return (E) a[index];}- 获取元素数组；
- 返回数组指定索引地位的元素；
remove(int index)办法
删除指定索引地位的元素。
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) // 如果移除的是最初一位 // 那么间接拷贝一份n-1的新数组, 最初一位就主动删除了 setArray(Arrays.copyOf(elements, len - 1)); else { // 如果移除的不是最初一位 // 那么新建一个n-1的新数组 Object[] newElements = new Object[len - 1]; // 将前index的元素拷贝到新数组中 System.arraycopy(elements, 0, newElements, 0, index); // 将index前面(不蕴含)的元素往前挪一位 // 这样正好把index地位笼罩掉了, 相当于删除了 System.arraycopy(elements, index + 1, newElements, index, numMoved); setArray(newElements); } return oldValue; } finally { // 开释锁 lock.unlock(); }}- 加锁；
- 获取指定索引地位元素的旧值；
- 如果移除的是最初一位元素，则把原数组的前len-1个元素拷贝到新数组中，并把新数组赋值给以后对象的数组属性；
- 如果移除的不是最初一位元素，则新建一个len-1长度的数组，并把原数组除了指定索引地位的元素全副拷贝到新数组中，并把新数组赋值给以后对象的数组属性；
- 解锁并返回旧值；
size()办法
返回数组的长度。
public int size() { // 获取元素个数不须要加锁 // 间接返回数组的长度 return getArray().length;}发问
为什么CopyOnWriteArrayList没有size属性？
因为每次批改都是拷贝一份正好能够存储指标个数元素的数组，所以不须要size属性了，数组的长度就是汇合的大小，而不像ArrayList数组的长度理论是要大于汇合的大小的。比方，add(E e)操作，先拷贝一份n+1个元素的数组，再把新元素放到新数组的最初一位，这时新数组的长度为len+1了，也就是汇合的size了。
总结
- CopyOnWriteArrayList应用
ReentrantLock重入锁加锁，保障线程平安； - CopyOnWriteArrayList的写操作都要先拷贝一份新数组，在新数组中做批改，批改完了再用新数组替换老数组，所以空间复杂度是O(n)，性能比拟低下；
- CopyOnWriteArrayList的读操作反对随机拜访，工夫复杂度为O(1)；
- CopyOnWriteArrayList采纳读写拆散的思维，读操作不加锁，写操作加锁，且写操作占用较大内存空间，所以实用于读多写少的场合；
- CopyOnWriteArrayList只保障最终一致性，不保障实时一致性。