CopyOnWrite 详解

为什会有 Copy On Write

COW 在不同的操作系统，或者框架中都会有相应的实现

优点

• COW 技术可以减少分配和赋值大量资源带来的瞬时延迟
• COW 可以减少不必要的资源分配。比如 fork 进程时，并不是所有的页面都需要赋值。父进程的代码段和只读数据段都不被允许修改，所以无需复制

缺点

• 如果在 fork 之后，父子进程都还需要继续进行写操作，那么会产生大量的分页错误，这样就得不偿失

回顾

我们都知道 ArrayList 是用于替代 Vector，Vector 是线程安全的容器。因为它几乎在每个方法声明处都加了 synchronized 关键字来保证容器安全。

如果使用 Collections.synchronizedList(new ArrayList()) 来使 ArrayList 变成线程安全的话，也就是每个方法都加上 synchronized 关键字，只不过不是在方法的声明处，而是在方法的内部

下面有一段代码

public static Object getLast(Vector list){
    int lastIndex = list.size() - 1;
    return list.get(lastIndex);
}

public static void deleteLast(Vector list){
    int lastIndex = list.size() - 1;
    return list.remove(lastIndex);
}

在多线程下是否有问题

答案是有的，因为这两个方法并不是原子性的，要保证这个线程安全不能仅仅给方法加锁，还要在遍历前给 vector 加锁。在遍历中，假设对 vector 的结构进行了破坏，例如 clear，则后续的操作可能并没有第一时间可见，继续进行操作，例如 get 读取数据，从而造成程序异常，所以最好的方法是遍历前个给 vector 加锁。

什么是 COW

多个调用者同时请求相同的资源，它们会共同获取相应的指针指向相同的资源，知道某个调用者试图修改资源内容时，系统才会真正赋值一个专用副本给调用者，而其他调用者所见到的最初的资源任然保持不变。

在 Java 中 COW 的一个应用就是 CopyOnWriteArrayList

• CopyOnWriteArrayList 相对于 ArrayList 线程安全，底层通过复制数组的方式来实现
• 在遍历使用时不会抛出 ConcurrentmodificationException 并且便利的时候就不用额外加锁
• 元素可以为 null

Java 中 CopyOnWriteArrayList 的实现

在 CopyOnWriteArrayList 中

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

对于 get 方法，直接返回数据

而对于 add 方法

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

clear 方法

public void clear() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        setArray(new Object[0]);
    } finally {
        lock.unlock();
    }
}

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

都要进行上锁，add 和 set 方法中还执行了 ArrayCopy 方法，进行拷贝，返回的是一个副本。

为什么在遍历时不需要显式加锁

查看源码发现 CopyOnWriteArrayList 实现 Iterator 的具体是 COWIterator

@SuppressWarnings("unchecked")
public E next() {
    if (! hasNext())
        throw new NoSuchElementException();
    return (E) snapshot[cursor++];
}

在返回数据的时候是 snapshot 这个数组中的数据就，这个数组是快照(snapshot)吗？

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

很明显不是的，构造函数中传入的就是原来的那个数组

CopyOnWriteArrayList你都不知道，怎么拿offer？

原文在这里，我还是不太明白

想了想，解释一下

因为对 List 具有结构性改变的操作都是按照 COW 实现的，即都是对数组的副本进行操作。

而我们遍历的时候用的是源本的数组，所以遍历的时候并不会造成影响

这篇文章也解决了我一直在意的一件事，为什么在对表遍历的时候，会抛出异常

其 COWIterator 的内部类实现如下

/**
 * Not supported. Always throws UnsupportedOperationException.
 * @throws UnsupportedOperationException always; {@code remove}
 *         is not supported by this iterator.
 */
public void remove() {
    throw new UnsupportedOperationException();
}
/**
 * Not supported. Always throws UnsupportedOperationException.
 * @throws UnsupportedOperationException always; {@code set}
 *         is not supported by this iterator.
 */
public void set(E e) {
    throw new UnsupportedOperationException();
}
/**
 * Not supported. Always throws UnsupportedOperationException.
 * @throws UnsupportedOperationException always; {@code add}
 *         is not supported by this iterator.
 */
public void add(E e) {
    throw new UnsupportedOperationException();
}

全部抛出不支持操作异常，怪不得

CopyOnWriteArrayList 的缺点

CopyOnWriteArrayList 同样有 COW 的缺点，本文开始就说了，只不过那时在操作系统中

• COW 会造成数据错误，不能实时保证数据一致性，但是可以保证最终一致性，可以保证最终一致性

  例如一个线程 get 了一个 value 走了，另外一个进去 remove 了同一个 value,

  实时上这个里面没有这个 value，但别的线程继续拿着这个 value 进行处理。

• 因为设计表结构的操作都要 copy，所以会造成内存占用偏高

CopyOnWriteArraySet

两者原理相同

public CopyOnWriteArraySet() {
    al = new CopyOnWriteArrayList();
}

最后

推荐这篇文章的原本博主 Java3y，感觉真的很强，看他的文章收获也很高

Java3y