java集合-CopyOnWrite系列

Copy-On-Write简称COW，是一种用于程序设计中的优化策略。其基本思路是，从一开始大家都在共享同一个内容，当某个人想要修改这个内容的时候，才会真正把内容Copy出去形成一个新的内容然后再改，这是一种延时懒惰策略。

什么是CopyOnWrite

CopyOnWrite容器即写时复制的容器。通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。这样做的好处是我们可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。

目前实现CopyOnWrite的并发容器有：CopyOnWriteArrayList和CopyOnWriteArraySet

线程安全的CopyOnWriteArrayList源码分析

public class CopyOnWriteArrayList<E>
    implements List<E>, 
    RandomAccess, 
    Cloneable, 
    java.io.Serializable

CopyOnWriteArrayList只实现了List接口，并没有继承extends AbstractList，意味着需要自己实现迭代器

看下面代码demo

List<String> copyArrayList = new CopyOnWriteArrayList<String>();
copyArrayList.add("3");
copyArrayList.remove(2);
copyArrayList.iterator();

初始化


    //2.这里可以看到CopyOnWriteArrayList的安全性是使用Lock来实现的
    final transient ReentrantLock lock = new ReentrantLock();

    private transient volatile Object[] array;

    final Object[] getArray() {
        return array;
    } 
    final void setArray(Object[] a) {
        array = a;
    }

    //1.实例化时默认数组大小为1；
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }

1.实例化时默认数组大小为1；
2.这里可以看到CopyOnWriteArrayList的安全性是使用Lock来实现。

添加

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

 final void setArray(Object[] a) {
        //将新数组指向到原始数组上
        array = a;
}

当每次添加一个元素时才动态扩展数组大小为1.每次扩展为size()+1；这里不管数组大小是否足够，每次都会新建一个数组，大小为原数组+1。
注意到没，每次添加元素时都会复制原数组，在原数组上+1，进行添加元素。
在添加的时候加锁，但是读取元素时读取的还是老数组，所以读不用加锁，不影响读的问题。但是缺点也很明显，就是在某一个时刻内存中会多了一个数组，随着list的数组量多时，在添加一个元素时，内存会一倍的被占用。

数据一致性问题。CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。所以如果你希望写入的的数据，马上能读到，请不要使用CopyOnWrite容器。

读取数据

读的时候不需要加锁，因为读取到时候读的是array数组。如果这个时候有数据添加或者删除，操作的都是新数组，并不会影响到我们读。

//new copy时初始化的
private transient volatile Object[] array;

final Object[] getArray() {
        return array;
}

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

//直接从array里面获取数据，没有加锁，也不需要加锁
private E get(Object[] a, int index) {
        return (E) a[index];
}

上面也提到过，CopyOnWrite是最终一致性，所以如果多线程环境下，一个线程正在添加一个元素，然后另外一个线程立马去读，有可能读取不到。它只能保证最终一致性。

删除

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 {
                //1.定义一个新数组长度为老的数组长度-1
                Object[] newElements = new Object[len - 1];
                //2.把删除元素的前面的数组元素复制到新数组里面
                System.arraycopy(elements, 0, newElements, 0, index);
                //3.把删除元素后面的数组元素复制到新数组里面
                System.arraycopy(elements, index + 1, newElements, index,numMoved);
                //4.返回一个新数组
                setArray(newElements);
            }
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

删除和ArrayList里面的删除也是很不一样的，copyOnwrite是新建一个数组，然后将删除元素坐标的前半段，后半段移动到新数组里面，然后再将原始数组指向新数组中。而ArrayList里面是在原数组中，如果删除了第2位，则后面的所有元素向前移动一位就OK了，始终是一个数组。

遍历

static final class COWIterator<E> implements ListIterator<E> {
        /** Snapshot of the array */
        private final Object[] snapshot;
        /** Index of element to be returned by subsequent call to next.  */
        private int cursor;

        private COWIterator(Object[] elements, int initialCursor) {
            cursor = initialCursor;
            snapshot = elements;
        }

        public boolean hasNext() {
            return cursor < snapshot.length;
        }

        public boolean hasPrevious() {
            return cursor > 0;
        }

         //读取下一个元素，其实就是一个迭代，里面每次cursor++，和for循环差不多
        @SuppressWarnings("unchecked")
        public E next() {
            if (! hasNext())
                throw new NoSuchElementException();
            return (E) snapshot[cursor++];
        }

        @SuppressWarnings("unchecked")
        public E previous() {
            if (! hasPrevious())
                throw new NoSuchElementException();
            return (E) snapshot[--cursor];
        }

        public int nextIndex() {
            return cursor;
        }

        public int previousIndex() {
            return cursor-1;
        }

        //迭代的时候不允许remove操作，直接抛异常
        public void remove() {
            throw new UnsupportedOperationException();
        }

        //霸气，直接抛异常
        public void set(E e) {
            throw new UnsupportedOperationException();
        }

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

        @Override
        public void forEachRemaining(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            Object[] elements = snapshot;
            final int size = elements.length;
            for (int i = cursor; i < size; i++) {
                @SuppressWarnings("unchecked") E e = (E) elements[i];
                action.accept(e);
            }
            cursor = size;
        }
    }

解说：霸气，只能用霸气来说明。这里定义了一个内部类COWIterator implements ListIterator 实现了ListIterator。
在遍历数组的时候，不能add,remove，如果外面的某个线程操作了add，直接抛异常。所以说霸气，在迭代遍历的时候禁止做一起事情，如果做了直接抛异常。

参考地址

http://ifeve.com/java-copy-on-write

java集合-CopyWrite系列

java集合-CopyOnWrite系列

什么是CopyOnWrite

线程安全的CopyOnWriteArrayList源码分析

初始化

添加

读取数据

删除

遍历

参考地址

猜你喜欢