目录
一、概述
Copy-On-Write是一种用于集合的并发访问的优化策略。
基本思想：
当我们往集合容器中写入元素的时候（添加、修改、删除），并不会直接在容器中写入，而是先将当前集合进行Copy，复制出一个新的容器，然后新容器里写入元素，写入操作完成后，再将原容器的引用指向新的容器。
好处：
实现对CopyOnWrite集合容器写入操作时的线程安全，但同时并不影响进行并发的读取操作。所以CopyOnWrite容器也是一种读写分离的思想。从JDK1.5开始Java并发包里提供了两个使用CopyOnWrite机制实现的并发集合容器，它们是CopyOnWriteArrayList和CopyOnWriteArraySet。
CopyOnWriteArrayList相当于线程安全的ArrayList，内壁存储结构采用Object[]数组，线程安全ReentrantLock实现，允许多个线程并发读取，但只有一个线程写入。
二、源码分析
retainAll():
//修改当前集合与当前集合的交集，如果集合内部改变返回true，否则返回false；
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;
//判断数组是否为空
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));
//返回true
return true;
}
}
//返回false
return false;
} finally {
//释放锁
lock.unlock();
}
}addAll()：
//将集合全部加入指定下标
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，则返回false
if (cs.length == 0)
return false;
int numMoved = len - index;
Object[] newElements;
//判断是否添加在数组尾部
if (numMoved == 0)
//复制数组，长度为len + cs.length
newElements = Arrays.copyOf(elements, len + cs.length);
else {
//否则，创建新数组，长度为数组长度+集合长度
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()方法
setArray(newElements);
//返回true
return true;
} finally {
//释放锁
lock.unlock();
}
}removeRange():
//删除区间范围数据
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();
}
}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)
//如果是,复制原数组,长度为len-1
setArray(Arrays.copyOf(elements, len - 1));
else {
//创建一个新数组，长度为len-1
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();
}
}add():
//在指定数组的指定位置添加
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)
//复制传入数组，长度为len+1
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()方法：将新数组赋值给定义数组
setArray(newElements);
} finally {
//释放锁
lock.unlock();
}
}
add():
//添加元素至末尾
public boolean add(E e) {
//加锁
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
//获取数组长度
int len = elements.length;
//复制原数组,长度为len+1
Object[] newElements = Arrays.copyOf(elements, len + 1);
//将要新元素添加至末尾
newElements[len] = e;
//更新数组
setArray(newElements);
//添加成功，返回true
return true;
} finally {
//释放锁
lock.unlock();
}
}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();
}
}三、总结
1.在保证并发读取的前提下，确保了写入时的线程安全；
2.由于每次写入操作时，进行了Copy复制原数组，所以无需扩容；
3.适合读多写少的应用场景。由于add() set() remove()等修改操作需要复制整个数组，所以会有内存开销大的问题；
4.CopyOnWriteArrayList由于只在写入时加锁，所以只能保证数据的一致性，不能保证数据的实时一致性。
扫一扫
552
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
