copyonwriteArrayList 源码解析
copyonwriteArrayList
本身是比较消耗内存的 ,因为可能存两份
写时复制:写操作的时候,会将list复制一份做写操作,操作完赋值回去 会在我们对copyonwriteArrayList操作的时候加锁,这里的加锁是不会阻塞读操作的
适合读多写少的操作,因为再写的时候会将list复制一份,复制的过程就比较消耗性能
同时对数据的一致性要求不是特别高,因为在修改一份数据的时候我们涉及到复制,然后加锁修改,然后再将脏数据更新这一连串操作
public class CopyOnWriteArrayList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
private static final long serialVersionUID = 8673264195747942595L;
/** The lock protecting all mutators */
final transient ReentrantLock lock = new ReentrantLock();
/** The array, accessed only via getArray/setArray. */
private transient volatile Object[] array;
.....
}
这里面保存数据使用的是一个Object数组
与普通的list最明显的不同就是这里new了一个ReentrantLock
add()方法
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();
}
}
add()方法里面直接使用了ReetrantLock,在添加元素的时候就进行了加锁操作
这样一来,就可以保证,我们再进行添加操作的时候只有一份复制的数据,同样,添加完元素就会对锁释放
add(index,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(newElements);
} finally {
lock.unlock();
}
}
可以看到,最主要的是这里进行了两段的复制,整体流程如下:
1.找到要分割的点的下标
2.创建新的Object数组
3.将原数组的前办部分(0 ~ 分割点)复制到新数组的 0 ~ 分割点下标处
4.将数组的后半部分 (分割点+1 ~ 新数组的尾部)
5.将新加入的值填充到分割
6.最后一步,将数组设置回去
这种分段拷贝的方式一定程度上提升了性能,因为避免了在数组上进行数据的移动
addIfAbsent(E e):添加一个不存在的元素,如果存在就不添加
public boolean addIfAbsent(E e) {
Object[] snapshot = getArray();
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;
}
Object[] newElements = Arrays.copyOf(current, len + 1);
newElements[len] = e;
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}
这个方法里面使用了一个三目运算符,先调用了了indexOf方法,在这里面,对数据进行循环检索
如果存在,就直接返回false,如果数据不存在,就会继续调用addIfAbsent的重载方法进行添加
因为在addIfAbsent(E e)中是没有进行加锁操作的,所以在addIfAbsent(E e, Object[] snapshot)中
会重新获取数组,然后对数组的长度进行一次判断,如果是相同就是正常的添加
如果长度是不同的,就会获取长度较短的数组,在短数组里面寻找有没有当前插入元素的重复元素
这里其实就是相当于将这个数组分成了两段,我们会先对前半段进行查找,如果没有才会查找后半段
从一定程度上减少了检索次数,因为如果前半段有,就不会检索后半段,只有前半段没有才会检索后半段
public E get(int index) {
return get(getArray(), index);
}
private E get(Object[] a, int index) {
return (E) a[index];
}
get方法就很简单,直接获取数组的下标,但是如果参数据没有更新到getArray(),那么可能会造成数据不一致
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();
}
}
set方法也会涉及到加锁的操作,首先会获取到oldValue
如果set的值与原值不相等,那么就会复制一份新的数组,然后会将新的值赋值到新的数组
这里old数组并没有删除,没有主动制空让gc回收,因为old数组可能存在别的地方被引用
例如在某处调用了get方法指向old数组中的某个值