CopyOnWrite写入时复制
CopyOnWrite，即快照模式，写入时复制就是不同线程访问同一资源的时候，会获取相同的指针指向这个资源，只有在写操作，才会去复制一份新的数据，然后新的数据在被写操作完后立马被其他线程看到最新的数据变化，然后之前获取的指针会指向新的数据，但在写操作未结束时，其他线程仍然能访问最初的资源。此做法主要的优点是如果没有线程进行写操作，就不会进行数据副本的复制，因此多个线程只是读取操作时可以共享同一份资源。
CopyOnWrite可以并发的读，而不需要加锁，是一种读写分离的思想，读和写不同的容器。
下面以CopyOnWriteArrayList为例：
测试：
public static void main(String[] args) {
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
list.add("a");
list.add("b");
list.add("c");
System.out.println("主线程-0:"+list.toString());
new Thread(()->{
System.out.println("读子线程-0:"+list.toString());
}).start();
new Thread(()->{
list.add("d");
System.out.println("写子线程-0:"+list.toString());
}).start();
new Thread(()->{
System.out.println("读子线程-1:"+list.toString());
}).start();
list.add("e");
new Thread(()->{
System.out.println("读子线程-2:"+list.toString());
}).start();
System.out.println("主线程-1:"+list.toString());
new Thread(()->{
list.add("f");
System.out.println("写子线程-1:"+list.toString());
}).start();
System.out.println("主线程-2:"+list.toString());
new Thread(()->{
System.out.println("读子线程-3:"+list.toString());
}).start();
}
//=======结果========
主线程-0:[a, b, c]
读子线程-0:[a, b, c]
写子线程-0:[a, b, c, d]
读子线程-1:[a, b, c, d, e]//主线程写e立马被读子线程1发现
主线程-1:[a, b, c, d, e]//主线程写e后输出
读子线程-2:[a, b, c, d, e]
主线程-2:[a, b, c, d, e]
写子线程-1:[a, b, c, d, e, f]
读子线程-3:[a, b, c, d, e, f]CopyOnWriteArrayList.add/set/remove/get源码探究
add：
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);//重新拷贝一份新数组，长度+1
newElements[len] = e;//元素加入新数组
setArray(newElements);//数组引用重新指向新数组，即进行旧数组的覆盖
return true;
} 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();
}
}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];//创建新数组，长度-1
System.arraycopy(elements, 0, newElements, 0, index);//复制指定位置前面的数据
System.arraycopy(elements, index + 1, newElements, index,
numMoved);//复制指定位置后面的数据
setArray(newElements);//数组引用重新指向
}
return oldValue;
} finally {
lock.unlock();
}
}get：从中可以看到，没有加锁，直接返回指定位置的元素
public E get(int index) {
return get(getArray(), index);
}
private E get(Object[] a, int index) {
return (E) a[index];
}CopyOnWriteArrayList探讨：
- CopyOnWriteArrayList和Vector的比较：Vector每个方法都加了synchronized，相比CopyOnWriteArrayList只在写操作加锁性能要提升很多；
- CopyOnWriteArrayList适合读多写少的并发场景，比如配置、白名单，黑名单，商品类目的访问和更新场景、物流地址等变化非常少的数据；
- CopyOnWriteArrayList存在内存问题，即每次的写操作都要进行资源的复制、替换，如果资源对象占用的内存过大，可能导致频繁的Yong GC和Full GC，会造成程序的响应时间变长；
- CopyOnWriteArrayList尽量使用批量添加操作addAll方法；
- CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。
CopyOnWriteArraySet
一个Set使用内部CopyOnWriteArrayList其所有操作。
public class CopyOnWriteArraySet<E> extends AbstractSet<E>
implements java.io.Serializable {
private final CopyOnWriteArrayList<E> al;
public CopyOnWriteArraySet() {
al = new CopyOnWriteArrayList<E>();
}
public boolean add(E e) {
return al.addIfAbsent(e);
}
}
public class CopyOnWriteArrayList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
public boolean addIfAbsent(E e) {//如果元素已经存在，返回false，否则进行写操作(CopyOnWrite)
Object[] snapshot = getArray();
return indexOf(e, snapshot, 0, snapshot.length) >= 0 ? false :
addIfAbsent(e, snapshot);
}
}