CopyOnWriteArrayList是一个线程安全的List，使用较少，我们看一下他的实现。

1、类定义

public class CopyOnWriteArrayList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
final transient Object lock = new Object(); // 对象锁
private transient volatile Object[] array; // 缓存元素数组
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();
if (elements.getClass() != Object[].class)
elements = Arrays.copyOf(elements, elements.length, Object[].class);
}
setArray(elements);
}
}

从类的定义和成员变量来看，与ArrayList近似，只是无法一开始指定大小，而大小也不需要指定，我们往下看

2、同步机制

我们先看插入元素的方法

public boolean add(E e) {
synchronized (lock) {
Object[] elements = getArray();
int len = elements.length;
Object[] newElements = Arrays.copyOf(elements, len + 1);
newElements[len] = e;
setArray(newElements);
return true;
}
}

写入的方法实现其实就是先把元素拷贝到到一个新的数组里，并且新的数组长度等于原数组长度+1。
我们再看一下读取方法：

public E get(int index) {
return get(getArray(), index);
}
private E get(Object[] a, int index) {
return (E) a[index];
}

可以看到没有增加锁，而是直接读。所以我们得出如下结论：
CopyOnWriteArrayList是写时才上锁，读是不会因为写而被锁住，而实现这个机制的原因，就是写数组的操作，并不会立即变更元素数组，而是生成一个新的数组，直接进行替换。这样可以保证读不受影响。但是会带来一个问题，就是读的值有可能不是最新的值，尤其是频繁读写的话，读的值会存在很多情况的滞后。这其实就是CopyOnWriteArrayList不常用原因，他只能适用于，频繁读，较少写的场景。

3、后记

除了CopyOnWriteArrayList可以实现List的同步，还有一个Collections的
public static List synchronizedList(List list)方法，实现原理很简单，就是适配原有list为一个SynchronizedList，然后给所有方法加锁，看一下简单的代码截取。

static class SynchronizedList<E>
extends SynchronizedCollection<E>
implements List<E> {
private static final long serialVersionUID = -7754090372962971524L;

final List<E> list;

SynchronizedList(List<E> list) {
super(list);
this.list = list;
}

public E get(int index) {
synchronized (mutex) {return list.get(index);}
}
public E set(int index, E element) {
synchronized (mutex) {return list.set(index, element);}
}
public void add(int index, E element) {
synchronized (mutex) {list.add(index, element);}
}
public E remove(int index) {
synchronized (mutex) {return list.remove(index);}
}
}