本文作者：王一飞，叩丁狼高级讲师。原创文章，转载请注明出处。
接上篇讲的并发中的list， 今天来聊聊CopyOnWriteArrayList。
概念
CopyOnWriteArrayList 类是JDK1.5引入的处理并发操作的容器类，他是Arraylist类的一种线程安全的变种，在并发环境下， 保证集合的读与写安全。
CopyOnWriteArrayList类是线程安全的容器，但它的安全是有一定的限制的。他的线程安全操作针对是并发环境下线程读与写安全。简单的讲, 它只能保证, 一边线程主读(遍历/获取), 一边线程主写(添加/删除/修改)操作上的安全。如果一边线程读写复合操作，另一边线程也读写复合操作，那它也无能为力啦。
案例1:CopyOnWriteArrayList 无法保证非读写模式线程安全
比如: 上篇测试例子
public class App {
public static void main(String[] args) {
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
list.add("1");
list.add("2");
new Thread(new Runnable() {
public void run() {
//集合大小
int len = list.size();
try {
//睡5s
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//删除最后一个
list.remove(len-1);
}
}, "t1").start();
new Thread(new Runnable() {
public void run() {
//清空集合
list.clear();
}
}, "t2").start();
}
}
将ArrayList换成CopyOnWriteArrayList, 依然存在数组越界问题, 原因就是上面说的CopyOnWriteArrayList仅保证一线程主读, 一线程主写, , 例子中t1线程复合操作,基友读又有写难于保证操作安全.
案例2:ConcurrentModificationException 异常解析
再看下面例子： 一个线程forEach遍历list集合， 另一线程删除list集合元素
public class App {
public static void main(String[] args) {
//CopyOnWriteArrayList
final Vector<String> list = new Vector<>();
//final ArrayList<String> list = new ArrayList<>();
for(int i =0;i < 1000; i++){
list.add(i+"");
}
new Thread(new Runnable() {
public void run() {
for(String s : list){
System.out.println(s);
}
}
}, "t1").start();
new Thread(new Runnable() {
public void run() {
for (int i = 0; i < list.size(); i++)
{
list.remove(i);
}
}
}, "t2").start();
}
}
使用普通的ArrayList 或者使用单操作线程安全的Vector, 多次执行,有很大概率抛出一个非常经典的线程异常:
Exception in thread "t1" java.util.ConcurrentModificationException
at java.util.Vector$Itr.checkForComodification(Vector.java:1184)
at java.util.Vector$Itr.next(Vector.java:1137)
at cn.wolfcode.ch14.App$1.run(App.java:19)
at java.lang.Thread.run(Thread.java:745)
分析:
ConcurrentModificationException 异常是Collection 集合定义一个用于限制多线程环境下集合并发修改的异常.比如: 某个线程在 Collection 上进行迭代时，另一个线程试图修改该 Collection。在这些情况下，第一线程迭代结果就不确定了。所以当检测到这种行为，迭代器选择抛出此异常。
来看下源码, 它是怎么折腾: 以ArrayList为例
ArrayList:
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
//关键属性:继承自父类AbstractList
protected transient int modCount = 0;
}
modCount 属性继承自AbstractList, 用于记录的是集合被修改(任意能导致集合结构发生变化的操作)次数, 每次修改+1.
public boolean add(E e) {
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
list集合的forEach迭代, 底层使用迭代器模式实现的, 在Arraylist内部维护了一个迭代器类
private class Itr implements Iterator<E> {
int cursor; //迭代器游标, 指向下一个元素索引
int lastRet = -1; // 最后一个元素索引
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
在list调用forEach操作时回调用iterator 方法获取迭代器对象,
public Iterator<E> iterator() {
return new Itr();
}
此时回将list持有的modCount赋值给itr类中的expectedModCount 属性,当使用迭代器迭代list元素时, iter.next( ) 方法会执行, 执行前调用checkForComodification 方法, 检查modCount 是否等于expectedModCount
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
如果A线程在执行iter.next() 方法前, B线程对list集合做修改动作, 此时的modCount 就无法保证等于 expectedModCount , 故抛出ConcurrentModificationException异常.
回到案例, 线程t1做迭代操作, 线程t2做删除操作, 线程t2会对modCount进行修改, t1迭代器初始化的expectedModCount 属性, 肯定无法等于modCount, 所以抛出ConcurrentModificationException异常.
CopyOnWriteArrayList使用
案例中, list集合使用抛出ConcurrentModificationException阻止存在并发安全隐患的迭代. 那如果, 存在这么一场景, 线程t1只关心当前时刻持有的list集合的数据迭代. 不关心list的数据是否被修改呢?此时,可以使用CopyOnWriteArrayList作为操作的集合
public class App {
public static void main(String[] args) {
//final Vector<String> list = new Vector<>();
final CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
for(int i =0;i < 1000; i++){
list.add(i+"");
}
new Thread(new Runnable() {
public void run() {
for(String s : list){
System.out.println(s);
}
}
}, "t1").start();
new Thread(new Runnable() {
public void run() {
for (int i = 0; i < list.size(); i++)
{
list.remove(i);
}
}
}, "t2").start();
}
}
上述案例如果使用CopyOnWriteArrayList作为迭代集合, 线程t1可以很愉快输出0~1000的数据, 它是怎么做到? 这得从CopyOnWriteArrayList原理说起.
CopyOnWriteArrayList类的设计理念，是基于一种叫Copy-On-Write(简称COW)设计思路，通俗的说就是读与写分离。具体可以看下图:
最初CopyOnWriteArrayList使用array数据存放list集合数据
当使用迭代器对CopyOnWriteArrayList进行遍历, 迭代器会给array弄一个快照,snapshot指向与array数组数据.具体代码:CopyOnWriteArrayList 源码
public Iterator<E> iterator() {
return new COWIterator<E>(getArray(), 0);
}
static final class COWIterator<E> implements ListIterator<E> {
/** Snapshot of the array */
private final Object[] snapshot;
private int cursor;
private COWIterator(Object[] elements, int initialCursor) {
cursor = initialCursor;
snapshot = elements;
}
}
此时, 如果有其它线程对相同的list做写操作, 比如add元素
CopyOnWriteArrayList 将array复制一份赋值个newElments,然后在新的数组中做写操作, 操作结束后, 让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();
}
}
final Object[] getArray() {
return array;
}
final void setArray(Object[] a) {
array = a;
}
注意观察, 在写操作时, 使用lock.lock();进行加锁, 保证写安全.
回到上面案例, 线程t1在迭代时一直使用的最初的array快照snapshot, 线程t2的写操作修改的都是新的array对snapshot没有任何影响, 所以可以从0打印到999
存在问题
最后说下CopyOnWriteArrayList 的局限性:
1>每次写操作都需要复制, 内存占用比重高, 不适宜操作大量数据
2>无法保证数据实时一致, 只能保证最终数据一致.
所以CopyOnWriteArrayList 在读远大于写的场合使用才有一定意义.
到这本篇结束.
想获取更多技术视频，请前往叩丁狼官网：http://www.wolfcode.cn/openClassWeb_listDetail.html
