CopyOnWriteArrayList类为何能保证线程安全

  CopyOnWriteArrayList与ArrayList相比多出了CopyOnWrite部分，这也反映出了前者在底层所使用的原理，即写入时复制策略。
  CopyOnWrite，简称COW，是一种优化策略。使用COW来实现读写分离操作，其原理是当多个线程对同一个资源的操作，分为读操作和写操作。
  对于读操作来说，不需要同步，因为大家读到的都是一样的。
  对于写操作来说，需要同步，因为你改我也改很有可能出现覆盖导致数据出错，因此需要保证在同一时间只有一个线程在操作。
  基于此原理，CopyOnWriteArrayList类对修改集合的操作进行加锁，但是对读取集合的操作不进行加锁。
  CopyOnWriteArrayList在修改集合时，先从原有的集合获取一个副本，在这个副本中添加元素，然后再用这个副本替换原有的集合。这便是写入时复制。
  加入本人最初的问题，在线程读取时替换集合不会造成读取错误吗？其实，仔细想想发现，在读取时读的是原集合，写入时写的是集合副本，这两个集合根本就是两块内存区域互不影响；集合在替换时替换的是指针，原有的集合的地址已经被读线程获取了。即使在读线程读时，写线程替换集合也不会对读线程持有的集合有任何影响。

接下来是源码部分：

/**
 * The lock protecting all mutators.  (We have a mild preference
 * for builtin monitors over ReentrantLock when either will do.)
 * 在jdk8后该类实现没有再使用ReentrantLock类而是使用synchronized(lock)方法，
 * 但其实是一样的，只是作者更喜欢后者这种写法而已。
 */
final transient Object lock = new Object();

private transient volatile Object[] array;

// 所有获取和替换集合的操作都必须使用这两种方法来实现
final Object[] getArray() {
   return array;
}
final void setArray(Object[] a) {
   array = a;
}

public boolean add(E e) {
     synchronized (lock) {
         Object[] es = getArray(); // 获取集合
         int len = es.length;
         es = Arrays.copyOf(es, len + 1); // 集合副本
         es[len] = e;
         setArray(es); // 替换集合
         return true;
    }
}
public E remove(int index) {
        synchronized (lock) {
            Object[] es = getArray();
            int len = es.length;
            E oldValue = elementAt(es, index);
            int numMoved = len - index - 1;
            Object[] newElements;
            if (numMoved == 0)
                newElements = Arrays.copyOf(es, len - 1);
            else {
                newElements = new Object[len - 1];
                System.arraycopy(es, 0, newElements, 0, index);
                System.arraycopy(es, index + 1, newElements, index,
                                 numMoved);
            }
            setArray(newElements);
            return oldValue;
        }
    }
public E set(int index, E element) {
        synchronized (lock) {
            Object[] es = getArray();
            E oldValue = elementAt(es, index);
            if (oldValue != element) {
                es = es.clone(); // 集合的复制在这里
                es[index] = element;
                setArray(es);
            }
            return oldValue;
        }
    }
// 可以看到读操作并没有被同步
public E get(int index) {
    return elementAt(getArray(), index);
}
static <E> E elementAt(Object[] a, int index) {
    return (E) a[index];
}

  接下来我们来思考CopyOnWriteArrayList类的优缺点

优点：
1.线程安全。
2.读写分离，提高性能。

缺点
1.复制副本，内存占用较多，可能频繁触发gc
2.数据时效性差，读线程读取时，写线程修改集合，读线程读取的数据失效

根据优缺点可知，CopyOnWriteArrayList
适合读操作要远多于写操作的情况，
适合数据实时性要求较低的情况。

END