Java8集合系列之CopyOnWriteArrayList（三）

Posted on   |   In   |     |   visitors

CopyOnWriteArrayList

CopyOnWriteArrayList implements List, RandomAccess, Cloneable, java.io.Serializable，实现了随机访问，另外ArrayList和LinkedList是属于java.util.*包中，而CopyOnWriteArrayList是属于java.util.concurrent包中的，显然可知，后者是并发安全的集合。

Copy-On-Write简称COW，是一种用于程序设计中的优化策略。其基本思路是，从一开始大家都在共享同一个内容，当某个人想要修改这个内容的时候，才会真正把内容Copy出去形成一个新的内容然后再改，这是一种延时懒惰策略。从JDK1.5开始Java并发包里提供了两个使用CopyOnWrite机制实现的并发容器,它们是CopyOnWriteArrayList和CopyOnWriteArraySet。

construct

1
2
3
4
5
6
/**
 * 创建一个空的list.
 */
public CopyOnWriteArrayList() {
    setArray(new Object[0]);
}

add

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
private transient volatile Object[] array;//这里用volatile关键字修饰，应该是保证内存可见性
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 Object[] getArray() {
    return array;
}
final void setArray(Object[] a) {
    array = a;
}

get

1
2
3
4
//读读不影响，不加锁
private E get(Object[] a, int index) {
    return (E) a[index];
}

remove

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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();
    }
}

小结

1、CopyOnWrite并发容器也是一种读写分离的思想，读和写不同的容器。且用于读多写少的并发场景。如果频繁写，将会每次创建数组，效率低。
2、内存占用问题。因为CopyOnWrite的写时复制机制，所以在进行写操作的时候，内存里会同时驻扎两个对象的内存，旧的对象和新写入的对象，如果对象较大，那么这个时候很有可能造成频繁的Yong GC和Full GC。
3、数据一致性问题。CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。所以如果你希望写入的的数据，马上能读到，请不要使用CopyOnWrite容器。

参考

关于Java集合的小抄
JAVA中的COPYONWRITE容器