CopyOnWriteArrayList 源码分析
CopyOnWriteArrayList 位于 java.util.concurrent 包下,是一个线程安全的可变数组。内部采用写时复制策略,也就是增删改时加锁复制;读取数据时不加锁。
类图
添加元素
类中添加元素的方法很多 add(E e), add(int index, E element) 等,这里以 add(E e)进行分析。
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();
}
}
主要流程就是 加锁,复制新数组,添加元素到新数组,替换旧数组。由于读取是不加锁的,所以在 替换旧数组前,所有的读取都是基于 旧数组的。
移除元素
同样的这里以 remove(int index) 方法进行分析
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();
}
}
主要流程就是:加锁,复制,替换。 因为读取不加锁,所以在 remove操作步骤中的 替换 执行完成前,所有的读取都是基于 旧数组的。对于多线程来说,线程1 读取,线程2 删除并且已经执行完了 复制 操作,但由于还未执行 替换 操作,那么线程1仍然可以读取到被删除的元素,只有在线程2完成了替换之后,线程1才无法读取删除的元素。这就是写时复制策略的弱一致性问题。
迭代器
CopyOnWriteArrayList 中的迭代器使用的是其内部类 COWIterator。
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;
private COWIterator(Object[] elements, int initialCursor) {
cursor = initialCursor;
snapshot = elements;
}
}
构造方法是需要传入一个数组,和初始游标位置。这里与 ArrayList 的迭代器不同的是,ArrayList 遍历迭代器使用的是就是集合中存储元素的数组,而这里使用的是传入的数组。
在 获取迭代器之后,如果没有进行增删改(修改不一定会产生复制),则集合中与迭代器中持有的是同一个数组的引用;否则,持有的是两个不同的数组,也就是说其他线程对于集合的修改对于迭代器是不可见的,这样就有了 迭代器的弱一致性问题。如果为了保证迭代器中的数据的实时性,需要保证在获取迭代器之后,不会在产生数组的复制操作。另外,迭代器中的增删改方法实现是不可用的,也是因为这个问题。
使用场景
CopyOnWriteArrayList 适用于多线程 读多写少 的场景。如果写入操作多,建议使用 SynchronzedList线程安全数组。因为 CopyOnWriteArrayList 写操作的不单单需要加锁,更需要数组的复制,那就意味着,在新增操作时,堆中是存在两个数组的,如果是数组较大,且写入操作多,是有可能会造成频繁 GC的。这里给出测试数据
写操作
多线程分别向 CopyOnWriteArrayList 和 SynchronizedList 写入 50000 数据,对比速度
public static void add(){
System.out.println("Synchronized: 添加元素");
long synchronizedListAddStartTime = System.currentTimeMillis();
List synchronizedList = Collections.synchronizedList(new ArrayList<>());
IntStream.range(1,200000).parallel().forEach(synchronizedList::add);
System.out.println("Synchronized: 添加元素耗时(ms)----" + (System.currentTimeMillis() - synchronizedListAddStartTime));
System.out.println("CopyOnWriteArrayList: 添加元素");
long copyOnWriteArrayListAddStartTime = System.currentTimeMillis();
CopyOnWriteArrayList copyOnWriteArrayList = new CopyOnWriteArrayList();
IntStream.range(1,200000).parallel().forEach(copyOnWriteArrayList::add);
System.out.println("CopyOnWriteArrayList: 添加元素耗时(ms)----" + (System.currentTimeMillis() - copyOnWriteArrayListAddStartTime));
}
// 执行结果
Synchronized: 添加元素
Synchronized: 添加元素耗时(ms)----97
CopyOnWriteArrayList: 添加元素
CopyOnWriteArrayList: 添加元素耗时(ms)----1878