CopyOnWriteArrayList

它是arraylist线程安全的版本（add,set等操作），使用数组实现。创建时，会产生一个新的数组备份。
它在需要保证线程安全的遍历列表的时候，比较高效。

、

添加的时候，使用reentrantlock锁，每添加一个元素，就会新创建一个数组，把内容复制过去。

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

删除时，也是新创建数组。使用了锁同步

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

迭代器，创建了一个COWIterator，迭代器iterator创建的时候，使用快照记录当时的数组，在整个生命周期中不会改变。迭代器的remove,set,add方法都会抛出异常。

由于add,remove方法都会新创建数组，所以不会影响现有的迭代。

  public Iterator<E> iterator() {
        return new COWIterator<E>(getArray(), 0);
    }
 private COWIterator(Object[] elements, int initialCursor) {
            cursor = initialCursor;
            snapshot = elements;
        }

迭代器的add方法，直接抛出异常。

public void add(E e) {
            throw new UnsupportedOperationException();
        }

contains方法会调用o的equals方法判断是否存在

public boolean contains(Object o) {
        Object[] elements = getArray();
        return indexOf(o, elements, 0, elements.length) >= 0;
    }