CopyOnWriteArrayList相当于线程安全的ArrayList，内部存储结构采用Object[]数组，线程安全使用ReentrantLock实现，允许多个线程并发读取，但只能有一个线程写入（添加、修改、删除）。接下来，我们来分析一下CopyOnWriteArrayList的源码。
public class CopyOnWriteArrayList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable { //创建ReentrantLock锁对象
final transient ReentrantLock lock = new ReentrantLock(); //定义一个Object[]引用，加上volatile以保证可见性和有序性，下面称为“定义数组”
private transient volatile Object[] array;getArray()方法：调用此方法，会返回一个Object[]数组；
final Object[] getArray() {
return array;
}setArray(Object[] a)方法：调用此方法，会将传入的数组赋值给数组引用array；
final void setArray(Object[] a) {
array = a;
}无参构造方法：创建一个空数组，并调用setArray()方法；
public CopyOnWriteArrayList() {
setArray(new Object[0]);
} 有参构造方法：传入一个集合；
public CopyOnWriteArrayList(Collection<? extends E> c) {
//定义一个Object[]数组引用
Object[] elements;
//判断传入集合的类型是否是CopyOnWriteArrayList
if (c.getClass() == CopyOnWriteArrayList.class)
//如果是，调用getArray()方法
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()方法
setArray(elements);
} set(int index,E element)方法：传入指定下标和想要修改的值；
public E set(int index, E element) {
//加锁
final ReentrantLock lock = this.lock;
lock.lock();
try {
//调用getArray()方法，获取原数组
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();
}
}
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);
//添加成功，返回true
return true;
} finally {
//释放锁
lock.unlock();
}
} 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)
//复制传入数组，最后多复制一个“空位”
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();
}
} remove(int index)：删除指定下标位置的元素；
public E remove(int index) {
//加锁
final ReentrantLock lock = this.lock;
lock.lock();
try {
//调用getArray()方法
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()方法
setArray(newElements);
}
//返回删除前的原值
return oldValue;
} finally {
//释放锁
lock.unlock();
}
}
removeRange(int index,int toIndex)：删除指定区间范围的元素；
void removeRange(int fromIndex, int toIndex) {
//加锁
final ReentrantLock lock = this.lock;
lock.lock();
try {
//调用getArray()方法
Object[] elements = getArray();
//获取数组长度
int len = elements.length;
//如果开始下标小于0或者结束下标大于数组长度或者结束下标小于开始下标，
则抛出下标越界异常
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()方法
setArray(newElements);
}
} 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 {
//调用getArray()方法
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;
//如果不为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();
}
} clear()方法：清空集合
public void clear() {
//加锁
final ReentrantLock lock = this.lock;
lock.lock();
try {
//将数组长度变为0
setArray(new Object[0]);
} 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);
//如果传入集合长度为0，则返回false
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];
//复制原数组内容至传入下标之前，从下标+集合长度开始复制原数组元素至新
数组
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();
}
}
}
130
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
