CopyOnWrite线程安全集合

一、CopyOnWrite集合简介

CopyOnWrite集合包括CopyOnWriteArrayList，CopyOnWriteSet和CopyOnWriteHashMap，但CopyOnWriteHashMap使用较少，并发环境大多采用性能更高的cpncurrentHashMap。其实现线程安全的核心思想是读写分离，即在写的时候，将底层的数组拷贝一份，然后修改拷贝的数组，再将修改后的数组通过原子操作的方式赋值给底层数组，以实现线程安全

二、CopyOnWriteArrayList

2-1 底层结构

    final transient ReentrantLock lock = new ReentrantLock();

    /** The array, accessed only via getArray/setArray. */
    private transient volatile Object[] array;

        可以看到CopyOnArrayList底层的实现机理是一个volatile修饰的数组，意味着这个数组的修改对于其他线程是具有可见性的，进而保证了读写时的线程安全问题。

        lock是用来确保写写线程之间的安全性的，设置增删改的操作均需要加锁

2-2 get

public E get(int index) {
        return get(getArray(), index);
    }


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

与ArrayList类似，是获取数组中索引为index的元素。

2-3 add

public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            //核心代码，将原先的数组拷贝一份，但是长度为原先的长度+1
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            //在len索引处设置新值
            newElements[len] = e;
            //重新设置底层数组
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

        可以看到，代码的核心思想就是拷贝一份elements数组，但是将长度设置为len+1，进行添加操作时，在拷贝的数组newElements中进行添加操作。待添加完成后，将element设置为newElement。

         因为读和写操作的副本并不是同一个，因此，并不会存在线程安全的问题，而element采用volatile修饰，在修改完成后，对其他线程立即可见，因此，保证了读写的线程安全问题。

        同时在添加的过程中，使用了锁，保证了写写线程之间的安全性问题。

2-4 set

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

        在修改操作进行之前，首先需要比较element[index]上的值与修改后的值是否相同，若相同，则不做修改，若不同，拷贝一份数组，修改完成后，将拷贝的数组设置为element

2-5 remove

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

       对于删除操作，新建一个数组，将原数组除去index索引处元素外的其他元素均拷贝到新数组中，完成删除后，将element设置为新数组。

三、CopyOnWriteArraySet

        其底层实现机理与CopyOnArrayList相同，此处不再赘述，但set中是不能有重复元素的，因此对于set，其修改与添加操作较CopyOnWriteList有一些区别。

3-1 add

public boolean add(E e) {
        return al.addIfAbsent(e);
    }

    public boolean addIfAbsent(E e) {
        Object[] snapshot = getArray();
        //判断要插入的元素e在数组中是否存在
        return indexOf(e, snapshot, 0, snapshot.length) >= 0 ? false :
            addIfAbsent(e, snapshot);
    }
//在elements[]数组的[index,fence)区间中寻找是否存在o
private static int indexOf(Object o, Object[] elements,
                               int index, int fence) {
        if (o == null) {
            for (int i = index; i < fence; i++)
                if (elements[i] == null)
                    return i;
        } else {
            for (int i = index; i < fence; i++)
                if (o.equals(elements[i]))
                    return i;
        }
        return -1;
    }

        在添加新元素e之前，先判断元素e在底层数组snapshot中是否存在，若存在，则返回false,代表添加失败，因为set中不能有重复元素，若不存在，则执行添加操作。

private boolean addIfAbsent(E e, Object[] snapshot) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //获取最新的snapshot[]
            Object[] current = getArray();
            int len = current.length;
            //snapshot被其他线程修改过
            if (snapshot != current) {
                // Optimize for lost race to another addXXX operation
                int common = Math.min(snapshot.length, len);
                for (int i = 0; i < common; i++)
                    if (current[i] != snapshot[i] && eq(e, current[i]))
                        return false;
                if (indexOf(e, current, common, len) >= 0)
                        return false;
            }
            Object[] newElements = Arrays.copyOf(current, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

       由于上面执行indexOf时没有进行加锁操作，在执行到addIfAbsent()方法之前，底层的数组仍然有可能被修改，因此需要再次获取最新的snapshot，若：

        1）snapshot已经被修改且包含要插入的元素e，返回false

        2）snapshot已经被修改，但并不包含e，执行插入操作。

        3）snapshot没有被修改，执行插入操作。

        插入操作的实现原理与CopyOnArrayList相同，此处不再进行赘述。

四、CopyOnWrite的优点和缺点

优点：

1.实现较为简单

2.确保线程安全

缺点：

1.性能较差，每次进行增删改操作时均需要使用lock

2.在修改时，需要额外拷贝一份数组，造成系统资源的开销

因此CopyOnWrite在执行以写为主的并发操作时，性能较差。