jdk源码分析之CopyOnWriteArrayList

CopyOnWriteArrayList的原理

CopyOnWriteArrayList的核心思想是利用高并发往往是读多写少的特性，对读操作不加锁，对写操作，先复制一份新的数组，在新的数组上面修改，然后将新数组赋值给旧数组的引用，并通过volatile 保证其可见性，通过Lock保证并发写。

底层数据结构

private volatile transient Object[] array;
final Object[] getArray() {
return array;
final void setArray(Object[] a) {
array = a;
}

底层采用Object数组存储数据

数组使用volatile修饰保证可见性，不读缓存直接读写内存

数组使用private修饰限制访问与，只能通过getter和setter访问

数组使用transient修饰，表示序列化时忽略此字段（自己定制序列化操作）

定制序列化操作

因为Object数组被transient修饰，因此需要CopyOnWriteArrayList类自己制定序列化方案

方法writeObject和readObject处理对象的序列化。如果声明该方法，它将会被ObjectOutputStream调用而不是采用默认的序列化方案。ObjectOutputStream使用了反射来寻找是否声明了这两个方法。因为ObjectOutputStream使用getPrivateMethod，所以这些方法不得不被声明为priate以至于供ObjectOutputStream来使用。

在两个方法的开始处，调用了defaultWriteObject()和defaultReadObject()。它们做的是默认的序列化进程，就像写/读所有的non-transient和 non-static字段(但他们不会去做serialVersionUID的检查).通常说来，所有我们想要自己处理的字段都应该声明为transient。这样的话，defaultWriteObject/defaultReadObject便可以专注于其余字段，而我们则可为被transient修饰的字段定制序列化。

/**
* Saves the state of the list to a stream (that is, serializes it).
*/
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
s.defaultWriteObject();

Object[] elements = getArray();
// Write out array length
s.writeInt(elements.length);

// Write out all elements in the proper order.
for (Object element : elements)
s.writeObject(element);
}

先调用s.defaultWriteObject()对非transient修饰的字段进行序列化操作

然后序列化写入数组的长度，再循环写入数组的元素

/**
* Reconstitutes the list from a stream (that is, deserializes it).
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
// bind to new lock
resetLock();

// Read in array length and allocate array
int len = s.readInt();
Object[] elements = new Object[len];

// Read in all elements in the proper order.
for (int i = 0; i < len; i++)
elements[i] = s.readObject();
setArray(elements);
}

反序列化的时候先调用s.defaultReadObject()恢复没有被transient修饰的字段

然后为反序列化得到的CopyOnWriteArrayList对象创建一把新锁

接着恢复数组的长度，根据数组的长度创建一个Object的数组

然后恢复数组的每一个元素

读操作不加锁

public E get(int index) {
return get(getArray(), index);
}
private E get(Object[] a, int index) {
return (E) a[index];
}

读操作是直接通过getArray方法获取Object数组，然后通过下标index直接访问数据。读操作并没有加锁，也没有并发的带来的问题，因为写操作是加锁写数组的副本，写操作成功将副本替换为原数据，这也是写时复制名字的由来。

加锁写副本

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方法先通过lock加锁，然后获取index位置的旧数据，供最后方法返回使用

E oldValue = get(elements, index);

接着创建数组的副本，在副本上进行数据的替换

Object[] newElements = Arrays.copyOf(elements, len);

Arrays.copyOf(elements, len)方法将会从elements数组复制len个数据创建一个新的数组返回

然后在新数组上进行数据替换,然后将新数组设置为CopyOnWriteArrayList的底层数组

newElements[index] = element;

setArray(newElements);

最后在finally块里边释放锁

特定位置添加数据

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();
}
}

添加数据和替换数据类似，先加锁，然后数组下标检查，接着创建数组副本，在副本里边添加数据，将副本设置为CopyOnWriteArrayList的底层数组