初始化

首先看下无参构造函数，如下代码在内部创建了一个大小为 0 的 Object 数组作为 array 的初始值。

    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }

然后看下有参构造函数。

    //创建一个 list，其内部元素是入参 toCopyIn 的副本 
    public CopyOnWriteArrayList（E[] toCopyIn） {
        setArray（Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class)）；
    }
    //入参为集合，将集合里面的元素复制到本 list
    public CopyOnWriteArrayList（Collection<? extends E> c） {
        Object[] elements；
        if （c.getClass() == CopyOnWriteArrayList.class）
            elements = （(CopyOnWriteArrayList<? >)c）.getArray()；
        else {
            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）；
    }

添加元素

CopyOnWriteArrayList 中用来添加元素的函数有 add（E e）、add（int index, E element）、addIfAbsent（E e）和 addAllAbsent（Collection<? extends E> c）等，它们的原理类似，所以本节以 add（E e）为例来讲解。

public boolean add（E e） {
      //获取独占锁（1）
      final ReentrantLock lock = this.lock；
      lock.lock()；
      try {
          //(2)获取 array
          Object[] elements = getArray()；
          //(3)复制 array 到新数组，添加元素到新数组 
          int len = elements.length；
          Object[] newElements = Arrays.copyOf（elements, len + 1）；
          newElements[len] = e；
          //(4)使用新数组替换添加前的数组 
          setArray（newElements）；
          return true；
      } finally {
          //(5)释放独占锁 
          lock.unlock()；
      }
}

在如上代码中，调用 add 方法的线程会首先执行代码（1）去获取独占锁，如果多个线程都调用 add 方法则只有一个线程会获取到该锁，其他线程会被阻塞挂起直到锁被释放。

所以一个线程获取到锁后，就保证了在该线程添加元素的过程中其他线程不会对 array 进行修改。

线程获取锁后执行代码（2）获取 array，然后执行代码（3）复制 array 到一个新数组（从这里可以知道新数组的大小是原来数组大小增加 1，所以 CopyOnWriteArrayList 是无界 list），并把新增的元素添加到新数组。

然后执行代码（4）使用新数组替换原数组，并在返回前释放锁。由于加了锁，所以整个 add 过程是个原子性操作。需要注意的是，在添加元素时，首先复制了一个快照，然后在快照上进行添加，而不是直接在原来数组上进行。

获取指定位置元素

使用 E get（int index）获取下标为 index 的元素，如果元素不存在则抛出 IndexOutOfBoundsException 异常。

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

在如上代码中，当线程 x 调用 get 方法获取指定位置的元素时，分两步走，首先获取 array 数组（这里命名为步骤 A），然后通过下标访问指定位置的元素（这里命名为步骤 B），这是两步操作，但是在整个过程中并没有进行加锁同步。假设这时候 List 内容如图 5-2 所示，里面有 1、2、3 三个元素。

图 5-2

由于执行步骤 A 和步骤 B 没有加锁，这就可能导致在线程 x 执行完步骤 A 后执行步骤 B 前，另外一个线程 y 进行了 remove 操作，假设要删除元素 1。remove 操作首先会获取独占锁，然后进行写时复制操作，也就是复制一份当前 array 数组，然后在复制的数组里面删除线程 x 通过 get 方法要访问的元素 1，之后让 array 指向复制的数组。而这时候 array 之前指向的数组的引用计数为 1 而不是 0，因为线程 x 还在使用它，这时线程 x 开始执行步骤 B，步骤 B 操作的数组是线程 y 删除元素之前的数组，如图 5-3 所示。

图 5-3

所以，虽然线程 y 已经删除了 index 处的元素，但是线程 x 的步骤 B 还是会返回 index 处的元素，这其实就是写时复制策略产生的弱一致性问题。

修改指定元素

使用 E set（int index, E element）修改 list 中指定元素的值，如果指定位置的元素不存在则抛出 IndexOutOfBoundsException 异常，代码如下。

public E set(int index, E element) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            E oldValue = get(elements, index);
            if (oldValue ! = element) {
                int len = elements.length;
                Object[] newElements = Arrays.copyOf(elements, len);
                newElements[index] = element;
                setArray(newElements);
            } else {
                // Not quite a no-op; ensures volatile write semantics
                setArray(elements);
            }
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

如上代码首先获取了独占锁，从而阻止其他线程对 array 数组进行修改，然后获取当前数组，并调用 get 方法获取指定位置的元素，如果指定位置的元素值与新值不一致则创建新数组并复制元素，然后在新数组上修改指定位置的元素值并设置新数组到 array。如果指定位置的元素值与新值一样，则为了保证 volatile 语义，还是需要重新设置 array，虽然 array 的内容并没有改变。

删除元素

删除 list 里面指定的元素，可以使用 E remove（int index）、boolean remove（Object o）和 boolean remove（Object o, Object[] snapshot, int 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）
              setArray（Arrays.copyOf(elements, len -1)）；
          else {
              //分两次复制删除后剩余的元素到新数组 
                Object[] newElements = new Object[len -1]；
                System.arraycopy（elements, 0, newElements, 0, index）；
                System.arraycopy（elements, index + 1, newElements, index,
                                numMoved）；
                //使用新数组代替老数组 
                setArray（newElements）；
            }
            return oldValue；
        } finally {
            //释放锁 
            lock.unlock()；
        }
    }

如上代码其实和新增元素的代码类似，首先获取独占锁以保证删除数据期间其他线程不能对 array 进行修改，然后获取数组中要被删除的元素，并把剩余的元素复制到新数组，之后使用新数组替换原来的数组，最后在返回前释放锁。

弱一致性的迭代器

遍历列表元素可以使用迭代器。在讲解什么是迭代器的弱一致性前，先举一个例子来说明如何使用迭代器。

public static void main( String[] args )
  {
      CopyOnWriteArrayList<String> arrayList = new CopyOnWriteArrayList<>();
      arrayList.add("hello");
      arrayList.add("alibaba");
      Iterator<String> itr = arrayList.iterator();
      while(itr.hasNext()){
          System.out.println(itr.next());
      }
 }

输出如下。

迭代器的 hasNext 方法用于判断列表中是否还有元素，next 方法则具体返回元素。好了，下面来看 CopyOnWriteArrayList 中迭代器的弱一致性是怎么回事，所谓弱一致性是指返回迭代器后，其他线程对 list 的增删改对迭代器是不可见的，下面看看这是如何做到的。

public Iterator<E> iterator() {
    return new COWIterator<E>（getArray(), 0）；
}
static final class COWIterator<E> implements ListIterator<E> {
    //array 的快照版本 
    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 E next() {
        if （! hasNext()）
            throw new NoSuchElementException()；
        return （E） snapshot[cursor++]；
    }

在如上代码中，当调用 iterator（）方法获取迭代器时实际上会返回一个 COWIterator 对象，COWIterator 对象的 snapshot 变量保存了当前 list 的内容，cursor 是遍历 list 时数据的下标。

为什么说 snapshot 是 list 的快照呢？明明是指针传递的引用啊，而不是副本。如果在该线程使用返回的迭代器遍历元素的过程中，其他线程没有对 list 进行增删改，那么 snapshot 本身就是 list 的 array，因为它们是引用关系。但是如果在遍历期间其他线程对该 list 进行了增删改，那么 snapshot 就是快照了，因为增删改后 list 里面的数组被新数组替换了，这时候老数组被 snapshot 引用。这也说明获取迭代器后，使用该迭代器元素时，其他线程对该 list 进行的增删改不可见，因为它们操作的是两个不同的数组，这就是弱一致性。

下面通过一个例子来演示多线程下迭代器的弱一致性的效果。

public class copylist
{
    private static volatile CopyOnWriteArrayList<String> arrayList = new
CopyOnWriteArrayList<>()；
    public static void main（ String[] args ） throws InterruptedException
    {
      arrayList.add（「hello」）；
      arrayList.add（「alibaba」）；
      arrayList.add（「welcome」）；
      arrayList.add（「to」）；
      arrayList.add（「hangzhou」）；
      Thread threadOne = new Thread(new Runnable() {
            @Override
            public void run() {
                //修改 list 中下标为 1 的元素为 baba
                arrayList.set（1， 「baba」）；
                //删除元素 
                arrayList.remove(2)；
                arrayList.remove(3)；
            }
        })；
      //保证在修改线程启动前获取迭代器 
      Iterator<String> itr = arrayList.iterator()；
      //启动线程 
      threadOne.start()；
      //等待子线程执行完毕 
          threadOne.join()；
        //迭代元素 
      while(itr.hasNext()){
          System.out.println(itr.next())；
      }
    }
}

输出结果如下。

在如上代码中，main 函数首先初始化了 arrayList，然后在启动线程前获取到了 arrayList 迭代器。子线程 threadOne 启动后首先修改了 arrayList 的第一个元素的值，然后删除了 arrayList 中下标为 2 和 3 的元素。

主线程在子线程执行完毕后使用获取的迭代器遍历数组元素，从输出结果我们知道，在子线程里面进行的操作一个都没有生效，这就是迭代器弱一致性的体现。需要注意的是，获取迭代器的操作必须在子线程操作之前进行。