目录
一、什么是并发集合
二、CopyOnWriteArrayList的实现思想
三、CopyOnWriteArrayList的优点
四、CopyOnWriteArrayList的源码分析
构造方法:
add():
set(int index, E element):
remove(int index):
addAll(int index, Collection c):
retainAll(Collection c):
五、小结
一、什么是并发集合
为了更好的支持高并发任务处理.在Java中提供了支持高并发的处理类.同时为了保证集合操作的一致性.这些高并发的集合类依然实现了集合标准接口。本篇文章我们以CopyOnWriteArrayList来举例说明。
二、CopyOnWriteArrayList的实现思想
Copy-On-Write
简称COW
,是一种用于集合的并发访问的优化策略。基本思想是:当我们往一个集合容器中写入元素时(添加、修改、删除),并不会直接在集合容器中写入,而是先将当前集合容器进行Copy,复制出一个新的容器,然后新的容器里写入元素,写入操作完成之后,再将原容器的引用指向新的容器。
三、CopyOnWriteArrayList的优点
实现对CopyOnWrite
集合容器写入操作时的线程安全,但同时并不影响进行并发的读取操作。所以CopyOnWrite
容器也是一种读写分离的思想,CopyOnWriteArrayList
相当于线程安全的ArrayList
,内部存储结构采用Object[]
数组,线程安全使用ReentrantLock
实现,允许多个线程并发读取,但只能有一个线程写入。
四、CopyOnWriteArrayList的源码分析
本篇文章我们以CopyOnWriteArrayList中的几个方法的源码进行深入了解并发集合是如何实现的:
构造方法:
public class CopyOnWriteArrayList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
//定义ReentrantLock
final transient ReentrantLock lock = new ReentrantLock();
private transient volatile Object[] array;
//得到数组
final Object[] getArray() {
return array;
}
//返回新数组为传入的数组
final void setArray(Object[] a) {
array = a;
}
//无参构造方法:默认长度为0
public CopyOnWriteArrayList() {
setArray(new Object[0]);
}
//有参构造方法:传入一个Collection类型的集合
public CopyOnWriteArrayList(Collection<? extends E> c) {
Object[] elements;
//判断集合的类型是否与CopyOnWriteArrayList类型一致
if (c.getClass() == CopyOnWriteArrayList.class)
//如果一致则存入数组
elements = ((CopyOnWriteArrayList<?>)c).getArray();
else {
//如果不一致,先转变为数组
elements = c.toArray();
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elements.getClass() != Object[].class)
//复制
elements = Arrays.copyOf(elements, elements.length, Object[].class);
}
//重新指向复制后的数组
setArray(elements);
}
}
add():
添加新元素至集合时,会将当前数组Copy复制新数组,并将新元素添加至新数组,最后替换原数组。执行过程中,使用ReentrantLock加锁,保证线程安全,避免多个线程复制数组。
//添加
public boolean add(E e) {
//获取锁
final ReentrantLock lock = this.lock;
//加锁
lock.lock();
try {
//得到传入数组
Object[] elements = getArray();
int len = elements.length;
//创建新数组,长度为原数组长度+1
Object[] newElements = Arrays.copyOf(elements, len + 1);
//将添加元素存入新数组末尾
newElements[len] = e;
//返回新数组
setArray(newElements);
return true;
} finally {
//释放锁
lock.unlock();
}
}
set(int index, E element):
根据下标修改元素值时,首先判断原值与新值是否相等,相等的时候,直接指向原数组,如果值不相等,复制数组,修改新数组中的值,重新指向到新数组
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(int index):
删除指定下标元素。根据指定下标,从原数组中,Copy
复制其它元素至新数组,最后替换原数组。
// 删除指定下标的元素
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)
// 直接复制原数组长度-1
setArray(Arrays.copyOf(elements, len - 1));
else {
Object[] newElements = new Object[len - 1];
// 从0开始复制index个元素
System.arraycopy(elements, 0, newElements, 0, index);
// 原数组从index+1下标开始,新数组从index开始,复制numMoved个元素
System.arraycopy(elements, index + 1, newElements, index,
numMoved);
setArray(newElements);
}
return oldValue;
} finally {
// 解锁
lock.unlock();
}
}
addAll(int index, Collection<? extends E> c):
在原数组的指定位置添加新集合
// 在原集合指定位置添加新集合
public boolean addAll(int index, Collection<? extends E> c) {
// 指定集合转化成数组
Object[] cs = c.toArray();
// 加锁
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);
// 判断新集合是否为空
if (cs.length == 0)
return false;
int numMoved = len - index;
Object[] newElements;
// 判断指定下标是否是尾下标
if (numMoved == 0)
// 复制新数组并且长度是原数组长度+新数组长度
newElements = Arrays.copyOf(elements, len + cs.length);
else {
newElements = new Object[len + cs.length];
// 从0开始复制index个元素
System.arraycopy(elements, 0, newElements, 0, index);
// 从原集合从index下标开始,结果集合从index+新数组长度开始复制numMoved个元素
System.arraycopy(elements, index,
newElements, index + cs.length,
numMoved);
}
// 新数组从0开始,结果数组从index开始,复制新数组长度
System.arraycopy(cs, 0, newElements, index, cs.length);
// 设置数组为结果数组
setArray(newElements);
return true;
} finally {
// 解锁
lock.unlock();
}
}
retainAll(Collection<?> c):
获取集合的交集,并将原数组替换成交集集合
// 判断集合间是否有交集并把原集合更新成交集
public boolean retainAll(Collection<?> c) {
// 如果集合为空,抛出NullPointerException()异常
if (c == null) throw new NullPointerException();
// 加锁
final ReentrantLock lock = this.lock;
lock.lock();
try {
// 获取原数组
Object[] elements = getArray();
// 获取原数组长度
int len = elements.length;
// 判断长度是否为0
if (len != 0) {
// temp array holds those elements we know we want to keep
int newlen = 0;
// 创建新数组
Object[] temp = new Object[len];
// 遍历原数组
for (int i = 0; i < len; ++i) {
Object element = elements[i];
// 判断传入集合是否有原数组中元素
if (c.contains(element))
temp[newlen++] = element;
}
// 设置原集合为交集
if (newlen != len) {
setArray(Arrays.copyOf(temp, newlen));
return true;
}
}
return false;
} finally {
// 解锁
lock.unlock();
}
}
五、小结
当我们需要在线程不安全场景下使用 List 时,建议使用 CopyOnWriteArrayList,CopyOnWriteArrayList 通过锁 + 数组拷贝 + volatile 之间的相互配合,实现了 List 的线程安全。