CopyOnWriteArrayList源码阅读分析
1.1 CopyOnWriteArrayList介绍
CopyOnWriteArrayList是ArrayList的线程安全版本,内部也是通过数组实现,每次对数组的修改都完全拷贝一份新的数组来修改,修改完了再替换掉老数组,这样保证了只阻塞写操作,不阻塞读操作,实现读写分离。
-
CopyOnWriteArrayList实现了List, RandomAccess, Cloneable, java.io.Serializable等接口。
-
CopyOnWriteArrayList实现了List,提供了基础的添加、删除、遍历等操作。
-
CopyOnWriteArrayList实现了RandomAccess,提供了随机访问的能力。
-
CopyOnWriteArrayList实现了Cloneable,可以被克隆。
-
CopyOnWriteArrayList实现了Serializable,可以被序列化。
1.2 CopyOnWriteArrayList源码
public class CopyOnWriteArrayList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
private static final long serialVersionUID = 8673264195747942595L;
/** The lock protecting all mutators */
// 用于修改时加锁,使用transient修饰表示不自动序列化。
final transient ReentrantLock lock = new ReentrantLock();
/** The array, accessed only via getArray/setArray. */
// 真正存储元素的地方,使用transient修饰表示不自动序列化,使用volatile修饰表示一个线程对这个字段的修改另外一个线程立即可见。
private transient volatile Object[] array;
/**
* Gets the array. Non-private so as to also be accessible
* from CopyOnWriteArraySet class.
*/
final Object[] getArray() {
return array;
}
/**
* Sets the array.
*/
final void setArray(Object[] a) {
array = a;
}
1.2.1 CopyOnWriteArrayList构造方法
(1). CopyOnWriteArrayList()
无参构造
public CopyOnWriteArrayList() {
// 所有对array的操作都是通过setArray()和getArray()进行
setArray(new Object[0]);
}
final void setArray(Object[] a) {
array = a;
(2). CopyOnWriteArrayList(Collection<? extends E> c)
public CopyOnWriteArrayList(Collection<? extends E> c) {
Object[] elements;
if (c.getClass() == CopyOnWriteArrayList.class)
// 如果c也是CopyOnWriteArrayList类型
// 那么直接把它的数组拿过来使用
elements = ((CopyOnWriteArrayList<?>)c).getArray();
else {
// 否则调用其toArray()方法将集合元素转化为数组
// 重新拷贝一份数组
elements = c.toArray();
if (c.getClass() != ArrayList.class)
elements = Arrays.copyOf(elements, elements.length, Object[].class);
}
setArray(elements);
}
(3). CopyOnWriteArrayList(E[] toCopyIn)
把toCopyIn的元素拷贝给当前list的数组。
public CopyOnWriteArrayList(E[] toCopyIn) {
setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
}
1.2.2 CopyOnWriteArrayList增加元素(增)
(1). 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();
}
}
(2). add(int index, E element)
在指定索引位置添加元素
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)
// 如果插入的位置是最后一位
// 那么拷贝一个n+1的数组, 其前n个元素与旧数组一致
newElements = Arrays.copyOf(elements, len + 1);
else {
// 如果插入的位置不是最后一位
// 那么新建一个n+1的数组
newElements = new Object[len + 1];
// 拷贝旧数组前index的元素到新数组中
System.arraycopy(elements, 0, newElements, 0, index);
// 将index及其之后的元素往后挪一位拷贝到新数组中
// 这样正好index位置是空出来的
System.arraycopy(elements, index, newElements, index + 1,
numMoved);
}
// 将元素放置在index处
newElements[index] = element;
// 覆盖原数组
setArray(newElements);
} finally {
// 释放锁
lock.unlock();
}
}
(3). addAll(Collection<? extends E> c)
添加一个集合
public boolean addAll(Collection<? extends E> c) {
// 判断传入的集合类型是否是CopyOnWriteArrayList类型,如果不是的话,将其转换成CopyOnWriteArrayList类型
Object[] cs = (c.getClass() == CopyOnWriteArrayList.class) ?
((CopyOnWriteArrayList<?>)c).getArray() : c.toArray();
// 判断集合的元素是否为空,为空直接返回false
if (cs.length == 0)
return false;
final ReentrantLock lock = this.lock;
// 加锁
lock.lock();
try {
// 获取旧数组
Object[] elements = getArray();
int len = elements.length;
// 判断当前数组是否是空数组并且传入的C类型是否为CopyOnWriteArrayList或者ArrayListL类型,如果是的话直接覆盖旧数组
if (len == 0 && (c.getClass() == CopyOnWriteArrayList.class ||
c.getClass() == ArrayList.class)) {
// 覆盖旧数组
setArray(cs);
} else {
//讲旧数组拷贝一份长度为当期数组长度len+传入集合数组cs长度之和的数组
Object[] newElements = Arrays.copyOf(elements, len + cs.length);
// 将c拷贝进新数组
System.arraycopy(cs, 0, newElements, len, cs.length);
// 覆盖旧数组
setArray(newElements);
}
return true;
} finally {
// 释放锁
lock.unlock();
}
}
(4). addAll(int index, Collection<? extends E> c)
在指定索引位置添加一个集合
public boolean addAll(int index, Collection<? extends E> c) {
// 将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);
// 传入需要添加的集合为空,直接返回false
if (cs.length == 0)
return false;
int numMoved = len - index;
Object[] newElements;
if (numMoved == 0)
// 如果插入的位置是最后一位
// 那么拷贝一个n+1的数组, 其前n个元素与旧数组一致
newElements = Arrays.copyOf(elements, len + cs.length);
else {
// 如果插入的位置不是最后一位
// 那么新建一个len + cs.length的数组
newElements = new Object[len + cs.length];
// 拷贝旧数组到新数组中
System.arraycopy(elements, 0, newElements, 0, index);
// 将index + cs.length 及其之后的元素往后挪一位拷贝到新数组中
System.arraycopy(elements, index,
newElements, index + cs.length,
numMoved);
}
// 将cs拷贝进新数组
System.arraycopy(cs, 0, newElements, index, cs.length);
// 覆盖旧数组
setArray(newElements);
return true;
} finally {
// 释放锁
lock.unlock();
}
}
(5). addAllAbsent(Collection<? extends E> c)
添加一个集合如果这个集合不存在于数组中。
public int addAllAbsent(Collection<? extends E> c) {
// 转换成数组
Object[] cs = c.toArray();
// 判断c的类型是否是ArrayList类型,不是的话则进行克隆一份
if (c.getClass() != ArrayList.class) {
cs = cs.clone();
}
//判断c的长度,为0的话直接返回0
if (cs.length == 0)
return 0;
final ReentrantLock lock = this.lock;
// 加锁
lock.lock();
try {
// 获取旧数组
Object[] elements = getArray();
int len = elements.length;
int added = 0;
// uniquify and compact elements in cs
for (int i = 0; i < cs.length; ++i) {
Object e = cs[i];
// 遍历cs,挨个判断cs中的元素在旧数组中是否存在,如果不存在,则添加进cs中
if (indexOf(e, elements, 0, len) < 0 &&
indexOf(e, cs, 0, added) < 0)
cs[added++] = e;
}
if (added > 0) {
// 将旧数组拷贝进一个长度为旧数组长度+添加的集合长度的新数组
Object[] newElements = Arrays.copyOf(elements, len + added);
// 将cs拷贝进新数组
System.arraycopy(cs, 0, newElements, len, added);
// 覆盖旧数组
setArray(newElements);
}
// 返回添加的元素个数
return added;
} finally {
// 释放锁
lock.unlock();
}
}
/**
* o 查找的对象
* elements 被查找的数组列表
* index 开始位置
* fence 结束位置
**/
private static int indexOf(Object o, Object[] elements,
int index, int fence) {
if (o == null) {
for (int i = index; i < fence; i++)
if (elements[i] == null)
return i;
} else {
for (int i = index; i < fence; i++)
if (o.equals(elements[i]))
return i;
}
return -1;
}
(6) addIfAbsent(E e)
添加一个不存在数组中的元素
public boolean addIfAbsent(E e) {
// 获取旧数组快照
Object[] snapshot = getArray();
// 如果元素在旧数组中不存在,调用addIfAbsent进行添加数据
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;
}
// 拷贝一份n+1的数组
Object[] newElements = Arrays.copyOf(current, len + 1);
// 将元素放在最后一位
newElements[len] = e;
// 覆盖旧数组
setArray(newElements);
return true;
} finally {
// 释放锁
lock.unlock();
}
}
1.2.3 CopyOnWriteArrayList 删除元素
(1). 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)
// 如果移除的是最后一位
// 那么直接拷贝一份n-1的新数组, 最后一位就自动删除了
setArray(Arrays.copyOf(elements, len - 1));
else {
// 如果移除的不是最后一位
// 那么新建一个n-1的新数组
Object[] newElements = new Object[len - 1];
// 将前index的元素拷贝到新数组中
System.arraycopy(elements, 0, newElements, 0, index);
// 将index后面(不包含)的元素往前挪一位
// 这样正好把index位置覆盖掉了, 相当于删除了
System.arraycopy(elements, index + 1, newElements, index,
numMoved);
// 覆盖旧数组
setArray(newElements);
}
// 返回被删除的元素
return oldValue;
} finally {
// 释放锁
lock.unlock();
}
}
(2). remove(Object o)
根据元素删除
public boolean remove(Object o) {
// 获取旧数组
Object[] snapshot = getArray();
// 查找元素在旧数组中出现的位置
int index = indexOf(o, snapshot, 0, snapshot.length);
// 判断元素在旧数组中是否存在,存在的话调用remove(Object o, Object[] snapshot, int index) 进行删除
return (index < 0) ? false : remove(o, snapshot, index);
}
private boolean remove(Object o, Object[] snapshot, int index) {
final ReentrantLock lock = this.lock;
// 加锁
lock.lock();
try {
// 重新获取旧数组
Object[] current = getArray();
int len = current.length;
// 如果快照与之前的数组不一致,有修改,重新查找元素在旧数组中的索引
if (snapshot != current) findIndex: {
int prefix = Math.min(index, len);
for (int i = 0; i < prefix; i++) {
// 判断快照与当前数组中是否存在该元素
if (current[i] != snapshot[i] && eq(o, current[i])) {
index = i;
break findIndex;
}
}
if (index >= len)
return false;
if (current[index] == o)
break findIndex;
index = indexOf(o, current, index, len);
if (index < 0)
return false;
}
// 新建一个n-1的新数组
Object[] newElements = new Object[len - 1];
// 将前index的元素拷贝到新数组中
System.arraycopy(current, 0, newElements, 0, index);
// 将index后面(不包含)的元素往前挪一位
// 这样正好把index位置覆盖掉了, 相当于删除了
System.arraycopy(current, index + 1,
newElements, index,
len - index - 1);
// 覆盖旧数组
setArray(newElements);
return true;
} finally {
// 释放锁
lock.unlock();
}
}
(3).removeAll(Collection<?> c)
删除一个集合
public boolean removeAll(Collection<?> c) {
// c为null直接抛出异常
if (c == null) throw new NullPointerException();
final ReentrantLock lock = this.lock;
// 加锁
lock.lock();
try {
// 获取旧数组
Object[] elements = getArray();
int len = elements.length;
// 旧数组长度不为0进行下一步删除操作,否则直接返回false
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) {
//循环遍历数组,将数组中不包含c集合中的元素放入temp临时数组,即等于删除c集合中的元素
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();
}
}
(4). removeIf(Predicate<? super E> filter)
根据过滤条件进行删除
public boolean removeIf(Predicate<? super E> filter) {
// 判断过滤条件是否为null,为null抛出异常
if (filter == null) throw new NullPointerException();
final ReentrantLock lock = this.lock;
// 加锁
lock.lock();
try {
// 获取旧数组
Object[] elements = getArray();
int len = elements.length;
// 判断旧数组是否为空,为空则返回false
if (len != 0) {
int newlen = 0;
Object[] temp = new Object[len];
for (int i = 0; i < len; ++i) {
@SuppressWarnings("unchecked") E e = (E) elements[i];
// 循环遍历 将满足过滤条件的元素进行删除,不满足的元素放入temp数组中
if (!filter.test(e))
temp[newlen++] = e;
}
// 判断有无删除的元素,在删除完后将旧数组进行覆盖
if (newlen != len) {
setArray(Arrays.copyOf(temp, newlen));
return true;
}
}
return false;
} finally {
// 释放锁
lock.unlock();
}
}
(5). removeRange(int fromIndex, int toIndex)
删除指定区间的元素
fromIndex:开始索引
toIndex: 结束索引
void removeRange(int fromIndex, int toIndex) {
final ReentrantLock lock = this.lock;
// 加锁
lock.lock();
try {
// 获取旧数组
Object[] elements = getArray();
int len = elements.length;
// 判断索引是否越界
if (fromIndex < 0 || toIndex > len || toIndex < fromIndex)
throw new IndexOutOfBoundsException();
// 计算新数组长度
int newlen = len - (toIndex - fromIndex);
int numMoved = len - toIndex;
if (numMoved == 0)
// 如果删除整个数组,直接将旧数组覆盖清空
setArray(Arrays.copyOf(elements, newlen));
else {
// 创建一个newLen长度的新数组
Object[] newElements = new Object[newlen];
// 将fromIndex前的元素拷贝进新数组
System.arraycopy(elements, 0, newElements, 0, fromIndex);
// 将toIndex后的元素拷贝进新数组
System.arraycopy(elements, toIndex, newElements,
fromIndex, numMoved);
//覆盖旧数组
setArray(newElements);
}
} finally {
// 释放锁
lock.unlock();
}
}
(6). clear()
清空数组
public void clear() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
// 创建一个长度为0的数组将旧数组覆盖
setArray(new Object[0]);
} finally {
lock.unlock();
}
}
1.2.4 CopyOnWriteArrayList修改元素
(1).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();
}
}
1.2.5 CopyOnWriteArrayList查找元素
(1). get(int index)
获取指定索引的元素,支持随机访问,时间复杂度为O(1)。
public E get(int index) {
// 获取元素不需要加锁
// 直接返回index位置的元素
// 这里是没有做越界检查的, 因为数组本身会做越界检查
return get(getArray(), index);
}
final Object[] getArray() {
return array;
}
private E get(Object[] a, int index) {
return (E) a[index];
}
(2). size()
获取数组长度
public int size() {
return getArray().length;
}
1.3 CopyOnWriteArrayList总结
(1)CopyOnWriteArrayList使用ReentrantLock重入锁加锁,保证线程安全;
(2)CopyOnWriteArrayList的写操作都要先拷贝一份新数组,在新数组中做修改,修改完了再用新数组替换老数组,所以空间复杂度是O(n),性能比较低下;
(3)CopyOnWriteArrayList的读操作支持随机访问,时间复杂度为O(1);
(4)CopyOnWriteArrayList采用读写分离的思想,读操作不加锁,写操作加锁,且写操作占用较大内存空间,所以适用于读多写少的场合;
(5)CopyOnWriteArrayList只保证最终一致性,不保证实时一致性;