持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第11天，点击查看活动详情

CopyOnWriteArrayList源码分析

类的继承关系

CopyOnWriteArrayList实现了List、RandomAccess、Cloneable、Serializable接口

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable 

类的属性

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    // 版本序列号
    private static final long serialVersionUID = 8673264195747942595L;
    // 可重入锁
    final transient ReentrantLock lock = new ReentrantLock();
    // 对象数组，用于存放元素
    private transient volatile Object[] array;
    // 反射机制
    private static final sun.misc.Unsafe UNSAFE;
    // lock域的内存偏移量
    private static final long lockOffset;
    static {
        try {
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            Class<?> k = CopyOnWriteArrayList.class;
            lockOffset = UNSAFE.objectFieldOffset
                (k.getDeclaredField("lock"));
        } catch (Exception e) {
            throw new Error(e);
        }
    }
}

类的属性中有一把可重入锁，用来保证线程间的安全，Object数组使用了volatile进行修饰，用来存放具体的元素，保证了线程之间的可见性。

类的构造函数

• 默认无参构造

CopyOnWriteArrayList()

public CopyOnWriteArrayList() {
    setArray(new Object[0]);
}

• CopyOnWriteArrayList(Collection<? extends E>)型构造函数　 该构造函数用于创建一个按 collection 的迭代器返回元素的顺序包含指定 collection 元素的列表。

public CopyOnWriteArrayList(Collection<? extends E> c) {
    Object[] elements;
    if (c.getClass() == CopyOnWriteArrayList.class)
        // 获取c集合的数组
        elements = ((CopyOnWriteArrayList<?>)c).getArray();
    else {
        elements = c.toArray();
        if (c.getClass() != ArrayList.class)
            elements = Arrays.copyOf(elements, elements.length, Object[].class);
    }
    setArray(elements);
}

核心函数分析

setArray

初始化构造方法中频繁调用，方法比较简单，设置全局Object数组的值

final void setArray(Object[] a) {
    array = a;
}

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

该方法将指定元素追加到此列表的末尾，流程如下

1、获取锁，获取当前数组和当前数组的长度

2、复制当前数组到一个新的数组，并将传入的值添加到新数组的尾部

3、将新数组赋值给Object数组，并释放锁

addIfAbsent

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])) // 当前数组的元素与快照的元素不相等并且e与当前元素相等
                    // 表示在snapshot与current之间修改了数组，并且设置了数组某一元素为e，已经存在
                    // 返回
                    return false;
            if (indexOf(e, current, common, len) >= 0) // 在当前数组中找到e元素
                    // 返回
                    return false;
        }
        // 复制数组
        Object[] newElements = Arrays.copyOf(current, len + 1);
        // 对数组len索引的元素赋值为e
        newElements[len] = e;
        // 设置数组
        setArray(newElements);
        return true;
    } finally {
        // 释放锁
        lock.unlock();
    }
}
​

该方法用于添加不重复元素，如果添加的元素已经存在，则不添加直接返回，反之添加

添加流程如下：

• 获取锁，获取当前数组，判断当前数组是否等于快照

  • 如果等于当前快照，复制数组，并将元素添加至尾部，设置数组
  • 如果不等于快照，取长度较小的进行循环遍历，如果当前数组的元素与快照的元素不相等并且e与当前元素相等，表示在snapshot与current之间修改了数组，并且设置了数组某一元素为e，已经存在。

• 释放锁，返回

set

public E set(int index, E element) {
    // 可重入锁
    final ReentrantLock lock = this.lock;
    // 获取锁
    lock.lock();
    try {
        // 获取数组
        Object[] elements = getArray();
        // 获取index索引的元素
        E oldValue = get(elements, index);
​
        if (oldValue != element) { // 旧值等于element
            // 数组长度
            int len = elements.length;
            // 复制数组
            Object[] newElements = Arrays.copyOf(elements, len);
            // 重新赋值index索引的值
            newElements[index] = element;
            // 设置数组
            setArray(newElements);
        } else {
            // Not quite a no-op; ensures volatile write semantics
            // 设置数组
            setArray(elements);
        }
        // 返回旧值
        return oldValue;
    } finally {
        // 释放锁
        lock.unlock();
    }
}
​

此函数用于用指定的元素替代此列表指定位置上的元素，也是基于数组的复制来实现的。

remove

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) // 移动个数为0
            // 复制后设置数组
            setArray(Arrays.copyOf(elements, len - 1));
        else { // 移动个数不为0
            // 新生数组
            Object[] newElements = new Object[len - 1];
            // 复制index索引之前的元素
            System.arraycopy(elements, 0, newElements, 0, index);
            // 复制index索引之后的元素
            System.arraycopy(elements, index + 1, newElements, index,
                                numMoved);
            // 设置索引
            setArray(newElements);
        }
        // 返回旧值
        return oldValue;
    } finally {
        // 释放锁
        lock.unlock();
    }
}
​

CopyOnWriteArrayList的缺陷

1、消耗内存，可以看到在CopyOnWriteArrayList写数据的时候会先从原数组copy一个新的数组出来，如果这个数组很大很大，那么有可能会产生溢出

2、不能用于实时读的场景，因为拷贝数组需要时间，调用一个set后，可能读取的数据还是旧数据，但是CopyOnWriteArrayList做到了最终一致性