一、CopyOnWriteArrayList
Copy-On-Write
简称COW
,是一种用于集合的并发访问的优化策略。
基本思想是:当我们往一个集合容器中写入元素时(添加、修改、删除),并不会直接在集合容器中写入,而是先将当前集合容器进行Copy,复制出一个新的容器,然后新的容器里写入元素,写入操作完成之后,再将原容器的引用指向新的容器。
二、CopyOnWriteArrayList 源码分析
1.CopyOnWriteArrayList构造方法
// 无参构造,初始化一个Object数组
public CopyOnWriteArrayList() {
setArray(new Object[0]);
}
// 有参构造,参数为Collection子类
public CopyOnWriteArrayList(Collection<? extends E> c) {
Object[] elements;
// 初始化类型是CopyOnWriteArrayList
if (c.getClass() == CopyOnWriteArrayList.class)
// 获取参数的Array数组对象,存入
elements = ((CopyOnWriteArrayList<?>)c).getArray();
else {
// 初始化类型不是是CopyOnWriteArrayList,将集合转换为数组
elements = c.toArray();
// c.toArray might (incorrectly) not return Object[] (see 6260652)
// elements不是 Object[],将elements数组复制到一个Object数组中
if (elements.getClass() != Object[].class)
elements = Arrays.copyOf(elements, elements.length, Object[].class);
}
// 存入
setArray(elements);
}
2、add()方法
添加新的元素
// 添加新元素
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();
}
}
给指定下标添加元素
// 指定下标添加元素
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)
newElements = Arrays.copyOf(elements, len + 1);
else {
// 不是最后一个元素
newElements = new Object[len + 1];
// 复制下标元素之前的元素
System.arraycopy(elements, 0, newElements, 0, index);
// 复制下标元素之后的元素
System.arraycopy(elements, index, newElements, index + 1,
numMoved);
}
// 指定位置添加元素
newElements[index] = element;
// 调用setArray方法将新数组存到array数组
setArray(newElements);
} finally {
// 释放锁
lock.unlock();
}
}
添加一个集合到指定位置
//添加一个集合到指定位置
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);
// 传入集合大小为0
if (cs.length == 0)
return false;
int numMoved = len - index;
Object[] newElements;
// 指定下标在末尾,copy至末尾
if (numMoved == 0)
newElements = Arrays.copyOf(elements, len + cs.length);
else {
// 创建一个长度len + cs.length的数组
newElements = new Object[len + cs.length];
// 复制下标元素之前的元素
System.arraycopy(elements, 0, newElements, 0, index);
// 复制下标元素之后的元素
System.arraycopy(elements, index,
newElements, index + cs.length,
numMoved);
}
// 将集合复制到指定位置
System.arraycopy(cs, 0, newElements, index, cs.length);
// 存入
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}
3、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();
}
}
4、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];
System.arraycopy(elements, 0, newElements, 0, index);
System.arraycopy(elements, index + 1, newElements, index,
numMoved);
// 存入
setArray(newElements);
}
// 返回旧数组
return oldValue;
} finally {
lock.unlock();
}
}
删除指定长度的元素
// 删除指定长度的元素
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 {
// 创建一个新数组
Object[] newElements = new Object[newlen];
// 复制删除范围前的元素
System.arraycopy(elements, 0, newElements, 0, fromIndex);
// 复制删除范围后的元素
System.arraycopy(elements, toIndex, newElements,
fromIndex, numMoved);
// 存入
setArray(newElements);
}
} finally {
lock.unlock();
}
}
三、CopyOnWriteArrayList
优点
实现对CopyOnWrite集合容器写入操作时的线程安全,但同时并不影响进行并发的读取操作。所以CopyOnWrite
容器也是一种读写分离的思想。从JDK1.5
开始Java
并发包里提供了两个使用CopyOnWrite
机制实现的并发集合容器,它们是CopyOnWriteArrayList
和CopyOnWriteArraySet
。