Java并发编程12——CopyOnWrite系列

• CopyOnWrite系列
  • 写时复制；弱一致性；写加锁，读快照
• CopyOnWriteArrayList
  • 属性：reentrantLock + volatile Object[]
  • add方法：先加锁，复制写，改变引用对象，解锁
  • get方法：不加锁，对snapshot操作，存在弱一致性问题
• CopyOnWriteArraySet
  • 内部用CopyOnWriteArrayList来代理

---

12.1 CopyOnWrite

• CopyOnWrite的意思是写时复制，关于这个的容器集合都是线程安全的，但是会存在弱一致性问题
• 核心思想是：
  • 写数据时：先lock加锁，然后对原来的数组copy出一个副本，再往新的副本里添加这个新数据，最后把新副本的引用地址赋值给了之前那个旧的的容器地址。在添加这个数据的期间，其他线程如果要去读取数据，仍然是读取到旧的容器里的数据，所以会有弱一致性问题产生
  • 读数据时：不加锁
• 适用场景：读多写少 的场景
• 缺点
  • 存在弱一致性问题
  • 内存占用变大

---

12.2 CopyOnWriteArrayList

（1）属性和构造器

• ReentrantLock独占锁保证线程安全，volatile的Object[]数保证可见性
• 默认构造器和ArrayList一样，默认0，但是没有1.5倍扩容，每次都根据add的数量进行copyOnWrite

/** The lock protecting all mutators */
final transient ReentrantLock lock = new ReentrantLock();

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

public CopyOnWriteArrayList() {
    setArray(new Object[0]);
}

（2）相关读取方法

• 不加锁，直接读取旧数组，会产生弱一致性问题

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

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

（3）修改相关方法

• add(E e)：加独占锁 ——> 对新array作修改 ——> 把原来的array指向新array

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();//释放锁
    }
}

• add(index, E)：总体思想差不多，细节上有点出入
  • 如果index是数组最后一个，复用add(E e)
  • 如果index在数组中间：把index左边数组复制，把index右边数组复制，设置index的值 ——> 返回

    public void add(int index, E element) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            if (index > len || index < 0)
                throw new IndexOutOfBoundsException("Index: "+index+
                                                    ", Size: "+len);
            Object[] newElements;
            int numMoved = len - index;
            if (numMoved == 0)
                newElements = Arrays.copyOf(elements, len + 1);
            else {
                newElements = new Object[len + 1];
                System.arraycopy(elements, 0, newElements, 0, index);
                System.arraycopy(elements, index, newElements, index + 1,
                                 numMoved);
            }
            newElements[index] = element;
            setArray(newElements);
        } finally {
            lock.unlock();
        }
    }

• set(int index, E element)：加锁，先获取数组，再用get方法获取该Index上的值，再修改
• remove(int index)：加锁，与add方法一样（删除后复制到新数组）

（4）迭代器

• 迭代时：先获取一份snapshot，对snapshot遍历，所以会存在弱一致性问题

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;

    ...
}

---

12.3 CopyOnWriteSet

• CopyOnWriteArraySet使用一个CopyOnWriteArrayList来做代理，它的所有api都是依赖于CopyOnWriteArrayList来实现的
• 内部封装了一个CopyOnWriteArrayList，大多数操作都调用CopyOnWriteArrayList的方法

private final CopyOnWriteArrayList<E> al;

public CopyOnWriteArraySet() {
    al = new CopyOnWriteArrayList<E>();
}

• add()方法：调用CopyOnWriteArrayList.putIfAbsent()方法，后者会遍历数组，用equals比较重复元素

    public boolean add(E e) {
        return al.addIfAbsent(e);
    }
    
    public boolean addIfAbsent(E e) {
        Object[] snapshot = getArray();
        return indexOf(e, snapshot, 0, snapshot.length) >= 0 ? false :
            addIfAbsent(e, snapshot);
    }
    
    private boolean addIfAbsent(E e, Object[] snapshot) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] current = getArray();
            int len = current.length;
            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();
        }
    }    

---

Ref

https://www.jianshu.com/p/cd7a73e6bd78

https://blog.csdn.net/hua631150873/article/details/51306021