04、CopyOnWriteArrayList
瞧,为了引出 CopyOnWriteArrayList,我花了多少心思。
List<String> list = new CopyOnWriteArrayList();
list.add("沉默王二");
list.add("沉默王三");
list.add("一个文章真特么有趣的程序员");
for (String str : list) {
if ("沉默王二".equals(str)) {
list.remove(str);
}
}
System.out.println(list);
把 ArrayList 换成 CopyOnWriteArrayList,程序就能够正常执行了,输出结果如下所示。
[沉默王三, 一个文章真特么有趣的程序员]
1
之所以不抛出 ConcurrentModificationException 异常,是因为 CopyOnWriteArrayList 是 fail-safe 的,迭代器遍历的是原有的数组,remove 的时候 remove 的是复制后的新数组,然后再将新数组赋值给原有的数组。
不过,任何在获取迭代器之后对 CopyOnWriteArrayList 的修改将不会及时反映迭代器里。
CopyOnWriteArrayList<String> list1 =
new CopyOnWriteArrayList<>(new String[] {"沉默王二", "沉默王三"});
Iterator itr = list1.iterator();
list1.add("沉默王四");
while(itr.hasNext()) {
System.out.print(itr.next() + " ");
}
沉默王四并不会出现在输出结果中。
沉默王二 沉默王三
ArrayList 的迭代器 Itr 是支持 remove 的。
List<String> list = new ArrayList();
list.add("沉默王二");
list.add("沉默王三");
list.add("一个文章真特么有趣的程序员");
Iterator var3 = list.iterator();
while (var3.hasNext()) {
String str = (String) var3.next();
if ("沉默王二".equals(str)) {
var3.remove();
}
}
System.out.println(list);
程序输出的结果如下所示:
而 CopyOnWriteArrayList 的迭代器 COWIterator 是不支持 remove 的。
public void remove() {
throw new UnsupportedOperationException();
}
CopyOnWriteArrayList 实现了 List 接口,不过,它不在 java.util 包下,而在 java.util.concurrent 包下,算作是 ArrayList 的增强版,线程安全的。
顾名思义,CopyOnWriteArrayList 在进行写操作(add、set、remove)的时候会先进行拷贝,底层是通过数组复制来实现的。
Java 8 的时候,CopyOnWriteArrayList 的增删改操作方法使用的是 ReentrantLock(可重入锁,一个线程获得了锁之后仍然可以反复的加锁,不会出现自己阻塞自己的情况)。
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();
}
}
Java 14 的时候,已经改成 synchronized 块了。
public boolean add(E e) {
synchronized (lock) {
Object[] es = getArray();
int len = es.length;
es = Arrays.copyOf(es, len + 1);
es[len] = e;
setArray(es);
return true;
}
}
其中的 lock 是一个 Object 对象(注释上说和 ReentrantLock 有一点关系)。
/**
* The lock protecting all mutators. (We have a mild preference
* for builtin monitors over ReentrantLock when either will do.)
*/
final transient Object lock = new Object();
使用 ReentrantLock 性能更好,还是 synchronized 块性能更好,同学们可以试验一下。不过,从另外一些细节上看,Java 14 的写法比 Java 8 更简洁一些,其中就少了一个 newElements 变量的创建。
再来看 set() 方法:
public E set(int index, E element) {
synchronized (lock) {
Object[] es = getArray();
E oldValue = elementAt(es, index);
if (oldValue != element) {
es = es.clone();
es[index] = element;
}
// Ensure volatile write semantics even when oldvalue == element
setArray(es);
return oldValue;
}
}
同样使用了 synchronized 块,并且调用了封装好的 clone() 方法进行了复制。
然后来看 remove() 方法:
public E remove(int index) {
synchronized (lock) {
Object[] es = getArray();
int len = es.length;
E oldValue = elementAt(es, index);
int numMoved = len - index - 1;
Object[] newElements;
if (numMoved == 0)
newElements = Arrays.copyOf(es, len - 1);
else {
newElements = new Object[len - 1];
System.arraycopy(es, 0, newElements, 0, index);
System.arraycopy(es, index + 1, newElements, index,
numMoved);
}
setArray(newElements);
return oldValue;
}
}
synchronized 块是必须的,数组复制(System.arraycopy())也是必须的。
和 Vector 不同的是,CopyOnWriteArrayList 的 get()、size() 方法不再加锁。
public int size() {
return getArray().length;
}
public E get(int index) {
return elementAt(getArray(), index);
简单总结一下就是:第一,CopyOnWriteArrayList 在修改时,复制出一个新数组,修改的操作在新数组中完成,最后将新数组赋值给原有的数组引用。第二,CopyOnWriteArrayList 的写加锁,读不加锁。
CopyOnWriteArrayList 有很多优势,但数组复制是沉重的,如果写的操作比较多,而读的操作比较少,内存就会被占用得比较多;另外,CopyOnWriteArrayList 无法保证数据是实时同步的,因为读写操作是分离的,写的操作都建立在复制的新数组上,而读的是原有的数组。
05、最后
如果九年前,我就看到了这样一篇文章,一定就不会被老马刁难呢,保不准还能再拖延半个小时,让他多问二十个问题。但我想同学们一定是比我幸运的,至少现在看到了,不晚,对不对?