copyonwriteArrayList 源码解析

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数组中的某个值