CopyOnWriteArrayList源码剖析

红太狼 2021-04-06 14:49 614阅读 0赞

### 1.1前言 ###

CopyOnWriteArrayList是JAVA中的并发容器类，同时也是符合写时复制思想的CopyOnWrite容器。写时复制思想即是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。这样做的好处是我们可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。

### 1.2源码分析 ###

#### 1.2.1实现接口 ####

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

CopyOnWriteArrayList实现了List和RandomAccess接口，使得该容器可以具有列表的基本功能和随机访问的特性，并且实现了Cloneable接口和Serializable接口，表示可被克隆和序列化。

#### 1.2.2成员变量 ####

//重入锁
    final transient ReentrantLock lock = new ReentrantLock();
    
    //对象数组，用于存放数据，用volatile修饰
    private transient volatile Object[] array;

#### 1.2.3构造函数 ####

//设置数组
    final void setArray(Object[] a) {
        array = a;
    }
    
    //调用setArray，创建一个空的列表
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }
    
    //创建一个包含collection的列表
    public CopyOnWriteArrayList(Collection<? extends E> c) {
        Object[] elements;
        //判断集合C的类型是否是CopyOnWriteArrayList，如果是则获取集合的数组，否则进入else
        if (c.getClass() == CopyOnWriteArrayList.class)
            elements = ((CopyOnWriteArrayList<?>)c).getArray();
        else {
            elements = c.toArray();//将集合转为数组
            //判断elements的类型是否为Object[]类型，如果不是则转为Object[]类型
            if (elements.getClass() != Object[].class)
                elements = Arrays.copyOf(elements, elements.length, Object[].class);
        }
        setArray(elements);//设置数组
    }

//将toCopyIn转为Object[]类型，然后设置数组
    public CopyOnWriteArrayList(E[] toCopyIn) {
        setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
    }

#### 1.2.4get方法 ####

private E get(Object[] a, int index) {
        return (E) a[index];
    }
    
    public E get(int index) {
        return get(getArray(), index);
    }

final Object[] getArray() {
        return array;
    }

get方法没有加锁也没有cas操作，因此代码非常简单。

#### 1.2.5add方法 ####

//将指定元素添加到列表尾部
    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;//添加元素e
            setArray(newElements);//设置数组
            return true;
        } finally {
            lock.unlock();//释放锁
        }
    }

#### 1.2.6set方法 ####

//替换列表指定位置的元素
    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();//释放锁
        }
    }

#### 1.2.7remove方法 ####

//删除指定位置的元素
    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));//移动个数为0则表示移除的是数组的最后一个元素，复制elements数组，复制长度为length-1，然后设置数组
            else {
       //移动个数不为0
                Object[] newElements = new Object[len - 1];//创建一个新数组
                System.arraycopy(elements, 0, newElements, 0, index);//复制index之前的元素
                System.arraycopy(elements, index + 1, newElements, index,
                                 numMoved);//复制index之后的元素
                setArray(newElements);//设置数组
            }
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

### 1.3缺点 ###

*  内存占用问题，有可能造成频繁的垃圾回收。
 *  数据一致性问题，CopyOnWriteArrayList只能保证数据的最终一致性，不能保证数据的实时一致性。

### 1.4总结 ###

对于CopyOnWriteArrayList容器来说，只适合读多写少的并发场景下使用。