1.1 介绍
并发包中的并发List只有CopyOnWriteArrayList，它是一个线程安全的ArrayList。对其进行的修改操作都是在其底层的一个复制数组（快照）上进行的，也就是使用了写时复制策略。
CopyOnWriteArrayList类图
- 每一个CopyOnWriteArrayList对象里有一个array数组对象用来存放具体的元素；
- ReentrantLock独占锁对象用来保证同时只有一个线程对array进行修改
5.2 主要方法源码解析
5.2.1 添加元素
内部有很多添加元素的方法
以为add(E e)为例进行说明
/**
* Appends the specified element to the end of this list.
*
* @param e element to be appended to this list
* @return {@code true} (as specified by {@link Collection#add})
*/
public boolean add(E e) {
//获取独占锁，如果多个线程都调用add方法则只有一个线程会获取到该锁
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
//复制array到新数组，添加元素到新数组（新数组的大小是原数组大小增加1，所以CopyOnWriteArrayList是无界锁）
Object[] newElements = Arrays.copyOf(elements, len + 1);
newElements[len] = e;
//使用新数组替换添加元素前的数组
setArray(newElements);
return true;
} finally {
//释放独占锁
lock.unlock();
}
}
总结：
在添加元素时首先复制了一个快照，然后再快照上进行添加，而不是直接在原来的数组上进行。
5.2.2 获取元素
get方法获取元素
获取元素分为两步：
- 获取array数组；
- 通过index访问指定index位置处的元素。
注意在上述过程中并没有加锁的步骤，这就导致了假如有x、y两个线程。x线程get元素，y线程remove元素。x线程在执行完步骤1后y线程获得执行权，此时y线程获取独占锁，然后删除了x要获取的index位置的元素，但是x线程内保存的数组依旧是原来的线程，发生了幻读。这就是写时复制策略产生的若一致性问题。
5.2.3 修改指定元素
/**
* Replaces the element at the specified position in this list with the
* specified element.
*
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
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();
}
}
5.2.4 删除元素
/**
* Removes the element at the specified position in this list.
* Shifts any subsequent elements to the left (subtracts one from their
* indices). Returns the element that was removed from the list.
*
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
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();
}
}
5.2.5 弱一致性的迭代器
所谓的弱一致性指的是返回给迭代器后，其他线程对list的增删改对迭代器是不可见的。
package beautyofparllel;
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;
public class copyList {
private static volatile CopyOnWriteArrayList<String> arrayList = new CopyOnWriteArrayList<String>();
public static void main(final String[] args) throws InterruptedException {
arrayList.add("hello");
arrayList.add("alibaba");
arrayList.add("welcome");
arrayList.add("to");
arrayList.add("hangzhou");
Thread thread = new Thread(() -> {
arrayList.set(1,"baba");
arrayList.remove(2);
arrayList.remove(3);
});
//保证在修改线程启动前获取迭代器
Iterator<String> iterator = arrayList.iterator();
thread.start();
//等待子线程执行完毕
thread.join();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
并未获得增删改的结果，这就是弱一致性的体现
