关于 CopyOnWriteArrayList 的一个简单优化

75 阅读 0 评论 50 点赞

我是靠谱客的博主洁净过客，最近开发中收集的这篇文章主要介绍关于 CopyOnWriteArrayList 的一个简单优化，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

一、优化动机

COW 简介：增删改都会加锁并拷贝工作数组，在拷贝数组上做完增删改操作后，会把拷贝数组切换为工作数组，在这个过程中，不会阻塞读操作。

所以 COW 很适合于读多写少的情况。

但是如果写再多一点呢，或者大部分的增删改只发生在工作数组的末尾呢。对于这些情况，在有大量数据的业务场景中，每次写操作都要拷贝整个工作数组，是很不划算的。

二、优化实现

考虑大部分的增删改只发生在工作数组末尾的这种情况。

我们可以使用一个数组来保存初始数据，然后后续发生在数组末尾的增删改数据保存在另一个数组中。

这样对于大量的增删改操作就只需要拷贝后面那个较短的数组即可，而不需要拷贝整个数据。

所以我考虑使用两个数组来保存数据，两个数组在逻辑上当成一个数组的前后两段使用。

三、优化导致的问题和解决方案

3.1 读的效率问题

COW 最显著的优点，就是读很快，任何写操作都不会阻塞读操作。所以对 COW 的优化，也应该具有极高的读效率。

两个数组当成一个数组使用的这个优化，对读操作最明显的影响是，在每次读的时候，都需要判断读操作发生在两个数组中的哪一个上面。

对于这个问题，每次通过判断语句判断，显然是很影响效率的。

对应的解决办法是，利用 Java 底层对数组访问做的安全控制，我们在代码层面不加以判断，等底层判断发现越界并抛出数组越界异常之后，再去处理。
代码示意如下，

	public E get(int index) {
try{
return o[index]; // o 为第一段数组
} catch (ArrayIndexOutOfBoundsException e) {
return c[index-o.length]; // c 为第二段数组
}
}

可以看到，这样做，对于发生在比较长的第一段数组中的读完全没有任何影响。但对于读第二段较短的数组，由于需要捕获数组越界异常，并做一个减法下标映射，所以会稍微影响读效率。

另外，还有一个小问题是，最终抛出的越界异常是针对第二段数组的，给出的越界信息会不正确。不过这个小问题不关乎大局，完全可以忽略。
纠正数组越界信息，代码示意如下：

	public E get(int index) {
try{
return o[index]; // o 为第一段数组
} catch (ArrayIndexOutOfBoundsException e) {
try{
return c[index-o.length]; // c 为第二段数组
} catch (ArrayIndexOutOfBoundsException e1) {
// 抛出正确的越界信息
throw new ArrayIndexOutOfBoundsException(index);
}
}
}

3.2 读的正确性问题

上一个问题的解决方案，又会引发出另一个问题。
即，在读第二段数组中的元素时，第一段数组的长度不能变长。

举例说明，假设第一段数组长度为 10，第二段数组长度为 5。
此时用户想要 get(10)，读第一段数组时，发现越界转而去读第二段数组。
此时另一个用户在第一段数组中添加元素，并且已经执行完拷贝、增加、切换数组的操作。那么此时第一段数组的长度就变成了 11。前一个用户的 get(10) 执行到 c[index-o.length] 时，index-o.length 为 -1，此时变成想要访问第二段数组下标为 -1 的元素，显然会抛出原本不应该抛出的数组越界异常。

解决方案一：
不允许在第一段数组上增加元素。

解决方案二：
捕获发生在第二段数组上的数组越界异常。
如果发现是第一段数组变长所致，尝试重新读。有点自旋锁的意思。
代码示意如下，

	public E get(int index) {
try{
return o[index]; // o 为第一段数组
} catch (ArrayIndexOutOfBoundsException e) {
int i = 0;
try{
return c[i = index-o.length]; // c 为第二段数组
} catch (ArrayIndexOutOfBoundsException e1) {
if(i < 0) return get(index); // 重新读
else throw new ArrayIndexOutOfBoundsException(index);
}
}
}

对于读多写少的场景，完全可以这样递归读。

如果写操作比较频繁，也可以对第一段数组加锁，然后再次进行读操作。
代码示意如下，

	public E get(int index) {
try{
return o[index]; // o 为第一段数组
} catch (ArrayIndexOutOfBoundsException e) {
int i = 0;
try{
return c[i = index-o.length]; // c 为第二段数组
} catch (ArrayIndexOutOfBoundsException e1) {
if(i < 0){
synchronized (o) { // 此时，读操作有一定概率被阻塞
return get(index);
}
}else throw new ArrayIndexOutOfBoundsException(index);
}
}
}

这样，大多数的读，都和之前一样。只有在读第二段数组时，第一段数组变长，并且 index-o.length 为负这种情况，才会阻塞读操作。

四、示意代码

时间关系，只实现了构造方法和基本的增删改查。

package main;
import java.util.Arrays;
import java.util.Collection;
import java.util.concurrent.CopyOnWriteArrayList;
public class IncrementCOW<E> {
// 成员变量
private volatile Object[] o;
private CopyOnWriteArrayList<E> c = new CopyOnWriteArrayList<>();
// 构造方法
public IncrementCOW(){
o = new Object[0];
}
public IncrementCOW(E[] toCopyIn){
o = Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class);
}
public IncrementCOW(Collection<? extends E> c){
Object[] 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);
o = elements;
}
// 普通方法
public int size(){
return o.length + c.size();
}
@SuppressWarnings("unchecked")
private E get(Object[] a, int index) {
return (E) a[index];
}
public E get(int index) {
try{
return get(o, index);
}catch (ArrayIndexOutOfBoundsException e) {
int i = 0;
try{
return c.get(i = index-o.length);
}catch (ArrayIndexOutOfBoundsException e1) {
if(i < 0) return get(index); // 不加锁的方式
else throw new ArrayIndexOutOfBoundsException(index);
}
}
}
/**
* 没有同时给 o 和 c 加锁
* 所以在 set c 的时候，index 可能不是逻辑数组实时的下标
* 只保证 index 是用户调用 set 方法后逻辑数组一个快照的下标
* */
public E set(int index, E element) {
if(index < 0) throw new IndexOutOfBoundsException("Index: "+index);
int i;
synchronized (o) {
i = index-o.length;
if(i < 0){
E oldValue = get(o, index);
if(oldValue != element){
Object[] newElements = Arrays.copyOf(o, o.length);
newElements[index] = element;
o = newElements;
}
return oldValue;
}
}
return c.set(i, element);
}
public void add(E e) {
c.add(e);
}
// 同 set 方法，没有同时给 o 和 c 加锁
public void add(int index, E element) {
if(index < 0) throw new IndexOutOfBoundsException("Index: "+index);
int i;
synchronized (o) {
i = index-o.length;
if(i < 0){
Object[] newElements = new Object[o.length + 1];
System.arraycopy(o, 0, newElements, 0, index);
System.arraycopy(o, index, newElements, index + 1,
-i);
newElements[index] = element;
o = newElements;
}
}
c.add(i, element);
}
// 同 set 方法，没有同时给 o 和 c 加锁
public E remove(int index) {
if(index < 0) throw new IndexOutOfBoundsException("Index: "+index);
int i;
synchronized (o) {
i = index-o.length;
if(i < 0){
E oldValue = get(o, index);
int numMoved = -i - 1;
if(numMoved == 0)
o = Arrays.copyOf(o, o.length - 1);
else{
Object[] newElements = new Object[o.length - 1];
System.arraycopy(o, 0, newElements, 0, index);
System.arraycopy(o, index + 1, newElements, index,
numMoved);
o = newElements;
}
return oldValue;
}
}
return c.remove(i);
}
}