基于jdk1.7源码
一、无锁容器
CopyOnWriteArrayList是JDK5中添加的新的容器，除此之外，还有CopyOnWriteArraySet、ConcurrentHahshMap和ConcurrentLinkedQueue等，它们都是无锁容器。
所谓无锁，就是不需要使用对象内置锁(synchronized)或显示加锁(Lock),而是抛弃锁机制而使用其它一些策略来保证线程安全。
这些无锁容器背后的通用策略是：对容器的修改可以与读取操作同时发生，只要读取者只能看完成修改的结果即可。修改是在容器数据结构的某个部分的一个单独的副本(有时是整个数据结构的副本)上执行的，并且这个副本在修改过程中是不可视的。只有当修改完成时，被修改的结构才会自动地与主数据结构进行交换，之后读取者就可以看到这个修改了。
——from《java编程思想》p755
二、源码分析
类声明
public class CopyOnWriteArrayList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
属性
/** The lock protecting all mutators */
/** 重入锁*/
transient final ReentrantLock lock = new ReentrantLock(); /** The array, accessed only via getArray/setArray. */
/** 数组，只能通过getArray/setArray访问*/
private volatile transient Object[] array;
构造器
/**
* 构造器(构造一个空的数组)
*/
public CopyOnWriteArrayList() {
setArray(new Object[0]);
} /**
* 构造器(使用指定的容器来创建，按照原容器中元素的顺序)。
*/
public CopyOnWriteArrayList(Collection<? extends E> c) {
Object[] 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在创建时，并没有默认容量，这点跟ArrayList不同。
get方法
public E get(int index) {
return get(getArray(), index);
}
final Object[] getArray() {
return array;
}
读操作没有进行同步，因为CopyOnWriteArrayList的读和写分离。
add方法
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();
}
}
remove方法
public boolean remove(Object o) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
if (len != 0) {
// Copy while searching for element to remove
// This wins in the normal case of element being present
int newlen = len - 1;//新数组长度比原来少1
//构建新数组
Object[] newElements = new Object[newlen];
//遍历查找现有数组【不包含末位元素】
for (int i = 0; i < newlen; ++i) {
//若存在
if (eq(o, elements[i])) {
// found one; copy remaining and exit
//将待删除元素o的后续所有元素拷贝到新数组中【拷贝o后面所有元素】
for (int k = i + 1; k < len; ++k)
newElements[k-1] = elements[k];
setArray(newElements);
return true;
} else
//当前不是要找的目标元素o，顺便将元素拷贝到新数组中【多次循环累计的这个操作相当于拷贝目标元素之前位置的所有元素】
//【由此说明，即使不存在目标元素，依然要做拷贝现有数组的操作】
newElements[i] = elements[i];
}
// special handling for last cell
//【末位元素单独处理】
//如果末位元素是目标元素。此时，该拷贝的元素都已拷贝到新数组中，直接setArray(newElements)
if (eq(o, elements[newlen])) {
setArray(newElements);
return true;
}
//如果末位元素仍然不是目标元素，说明不存在目标元素。
//因为没有setArray(newElements),所以原数组依旧是原数组。
}
//现有元素数组为空，直接返回false
return false;
} finally {
lock.unlock();
}
}
迭代器
public Iterator<E> iterator() {
return new COWIterator<E>(getArray(), 0);
}
private static class COWIterator<E> implements ListIterator<E> {
//快照数组
private final Object[] snapshot;
private int cursor;
private COWIterator(Object[] elements, int initialCursor) {
cursor = initialCursor;
//
snapshot = elements;
}
public boolean hasNext() {
return cursor < snapshot.length;
}
public boolean hasPrevious() {
return cursor > 0;
}
@SuppressWarnings("unchecked")
public E next() {
if (! hasNext())
throw new NoSuchElementException();
//
return (E) snapshot[cursor++];
}
@SuppressWarnings("unchecked")
public E previous() {
if (! hasPrevious())
throw new NoSuchElementException();
//
return (E) snapshot[--cursor];
}
public int nextIndex() {
return cursor;
}
public int previousIndex() {
return cursor-1;
}
/**
* 迭代器不支持remove/set/add方法。
*/
public void remove() {
throw new UnsupportedOperationException();
}
public void set(E e) {
throw new UnsupportedOperationException();
}
public void add(E e) {
throw new UnsupportedOperationException();
}
}
总结
1.CopyOnWriteArrayList的工作原理？
CopyOnWriteArrayList在做修改操作时，每次都是重新创建一个新的数组，在新数组上操作，最终再将新数组替换掉原数组。因此，在做修改操作时，仍可以做读取操作，读取直接操作的原数组。读和写操作的目标都不同，因此读操作和写操作互不干扰，只有写与写之间需要进行同步等待。另外，原数组被声明为volatile，这就保证了，一旦数组发生变化，则结果对其它线程(读线程和其它写线程)是可见的。
2.CopyOnWriteArrayList适合的应用场景？
正是由于每次修改都会创建新数组，内存中都要同时存有原数组和新数组，同时也要将元素拷贝到新数组中，内存开销大，所以CopyOnWriteArrayList只适合于读多写少的场景。
比如某些系统级别的信息，往往只是需要加载或者修改很少的次数，但是会被系统内所有模块频繁的访问，对于这种场景，我们最希望看到的就是读操作尽可能地快，而写即使慢一些也没太大关系。
3.CopyOnWriteArrayList能否像ArrayList一样支持fail-fast？
CopyOnWriteArrayList并不支持fail-fast机制，所以不会抛出ConcurrentModificationException，也不必编写特殊的代码去防范这种异常。
4.CopyOnWriteArrayList的扩容
CopyOnWriteArrayList并不像ArrayList一样指定默认的初始容量。它也没有自动扩容的机制，而是添加几个元素，长度就相应的增长多少。
①因为CopyOnWriteArrayList适用于读多写少，既然是写的情况少，则不需要频繁扩容。
②修改操作每次在生成新的数组时就指定了新的容量，也就相当于扩容了，所以不需要额外的机制来实现扩容。