源码阅读系列——基础篇（CopyOnWriteArrayList 集合源码分析）

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);}
        }
    }