CopyOnWriteArrayList核心源码阅读及个人理解（附注释和过程解析）

猿究院-Gan饭者

已于 2023-07-17 22:59:22 修改

阅读量415

点赞数 3

CC 4.0 BY-SA版权

文章标签： java 开发语言 eclipse

于 2023-07-17 22:56:46 首次发布

本文链接：https://blog.youkuaiyun.com/A_diligent_man/article/details/131772640

CopyOnWriteArrayList是一个线程安全的ArrayList变种，采用Copy-On-Write策略确保并发读取时不会阻塞写操作。文章详细解读了其构造方法、get、set、add、remove等核心方法的源码，展示了如何在写操作时复制数组以实现线程安全，并分析了其在读写分离场景下的优缺点。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前言

本文章阅读CopyOnWriteArrayList常用方法的核心源码，解读实现过程。

一、CopyOnWriteArrayList

Copy-On-Write简称COW，是一种用于集合的并发访问的优化策略，可以说CopyOnWriteArrayList是一种线程安全的ArrayList集合，内部存储结构采用Object【】数组，线程安全使用ReentrantLock实现，允许多个线程并发读取，但只能有一个线程写入。

1.1、基本思想

当我们往一个集合容器中写入元素时（添加、修改、删除），并不会直接在集合容器中写入，而是先将当前集合容器进行Copy，复制出一个新的容器，然后新的容器里写入元素，写入操作完成之后，再将原容器的引用指向新的容器。

1.2、优缺点

优点：
实现对CopyOnWriteArrayList集合容器写入操作时的线程安全，但同时并不会影响进行并发的读取操作。所以CopyWrite也是一种读写分离的思想。
每次写入操作时，进行了Copy复制原数组，无需扩容；
缺点：
只适用于读多写少的应用场景。因为add（）、set（）、remove（）等修改操作需要复制整个数组，所以会有内存开销大的问题。
CopyOnWriteArrayList由于只在写入时加入锁，所以只能保证数据的最终一致性，不能保证数据的实时一致性。

二、常用方法及源码解读

2.1CopyOnWriteArrayList()

private transient volatile Object[] array;
public CopyOnWriteArrayList() {		
			//传入长度为0的Object数组
      setArray(new Object[0]);
}
final void setArray(Object[] a) {
  //将array数组引用指向a
  array = a;
}

由源代码可以得知，CopyOnWriteArrayList中有一个Object[] array数组，当调用无参构造方法时，会调用setArray()方法，而传入的是一个长度为0的Object数组，在setArray()方法中指向array数组。

2.2 get(int index)

public E get(int index) {
			//传入当前数组，索引下标
       return get(getArray(), index);
    }
@SuppressWarnings("unchecked")
private E get(Object[] a, int index) {
			//返回当前数组中index索引的对象
       return (E) a[index];
    }
final Object[] getArray() {
			//返回自身数组
      	return array;
    }

此方法可以根据index索引元素，在使用get(int index)时，会调用其私有的get(Object[] a, int index)方法，通过getArray()方法得到当前存储数据的数组array，根据index索引到目标元素，最终返回值。返回得到的元素对象。

2.3 set(int index, E element)

 public E set(int index, E element) {
 				//创建ReentrantLock锁对象lock
        final ReentrantLock lock = this.lock;
        //锁
        lock.lock();
        try {
        		//将elements 数组引用指向array数组
            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();
        }
    }

此方法中加入了ReentrantLock，可以保证调用此方法的线程安全，通过getArray() 方法获取当前存储数组的数组赋值给elements数组，再通过get(Object[] a, int index)方法拿到被替换的元素oldValue ，如果设置的新元素element不等于要被替换的oldValue元素，则通过Arrays.copyOf（）方法将原来的数组的数组复制到newElements数组，再将新元素根据index替换原来的元素，最终才使用setArray(newElements)方法将最终数据设置成最新存储数据的数组。返回值是被替换的元素。

2.4 add(E e)

public boolean add(E e) {
			//创建ReentrantLock锁对象lock
        final ReentrantLock lock = this.lock;
        //锁
        lock.lock();
        try {
        		//将elements 数组引用指向array数组
            Object[] elements = getArray();
            int len = elements.length;
            //将newElements数组指向复制了原来elements 内容并扩容一位的新数组；
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            //在数组的最后放入新元素
            newElements[len] = e;
            //将array引用指向newElements
            setArray(newElements);
            return true;
        } finally {
        //释放锁
            lock.unlock();
        }
    }

此方法同样也用了ReentrantLock锁来保证线程安全，其实现过程通过getArray()方法拿到当前数组elements，通过复制将数组容量+1的方式复制到比原数组长度大1的新数组，由int len = elements.length;和newElements[len] = e;可以得知此方法是将新元素添加到数组的最后一位，最终再将存储最终数据的数组setArray给array。返回值是添加是否成功的Boolean值。

2.5 add(int index, E element)

 public void add(int index, E element) {
 				//创建ReentrantLock锁对象lock
        final ReentrantLock lock = this.lock;
        //锁
        lock.lock();
        try {
        		//将elements 数组引用指向array数组
            Object[] elements = getArray();
            int len = elements.length;
            //如果下标月结或者小于0，则抛异常
            if (index > len || index < 0)
                throw new IndexOutOfBoundsException("Index: "+index+
                                                    ", Size: "+len);
            Object[] newElements;
            //将要移动的元素个数
            int numMoved = len - index;
            //移动的元素个数为0时，说明是添加到最后一位
            if (numMoved == 0)
                newElements = Arrays.copyOf(elements, len + 1);
            else {
            		//否则从index开始将原数组分为两部分，依次进行复制到新数组newElements 
                newElements = new Object[len + 1];
                System.arraycopy(elements, 0, newElements, 0, index);
                System.arraycopy(elements, index, newElements, index + 1,
                                 numMoved);
            }
            //按索引位置添加元素
            newElements[index] = element;
            //将array指向newElements
            setArray(newElements);
        } finally {
        		//释放锁
            lock.unlock();
        }
    }

此方法与add(E e)方法的不同点在于可以指定下标插入新元素，实现逻辑与add(E e)方法大同小异，先判断index是否小于0或者越界，否则抛异常。而在int numMoved = len - index;记录了要移动的元素个数，如果为numMoved为0，说明添加至最后一位，直接newElements = Arrays.copyOf(elements, len + 1);即可。否则通过 System.arraycopy(elements, 0, newElements, 0, index);和System.arraycopy(elements, index, newElements, index + 1, numMoved);方法将插入元素的index将数组（此数组为newElements）扩容一位并且分成两部分，通过两次数组复制到newElements中，最终通过newElements[index] = element;插入新元素，最终setArray成最终使用的数组array。

2.6 addAll(Collection<? extends E> c)

public boolean addAll(Collection<? extends E> c) {
				//如果c对象所属的类与CopyOnWriteArrayList的类一致，则通过getArray()方法获取数组，否则用toArray()方法转换成数组
        Object[] cs = (c.getClass() == CopyOnWriteArrayList.class) ?
            ((CopyOnWriteArrayList<?>)c).getArray() : c.toArray();
        //如果cs数组为空，说明无添加元素，返回false
        if (cs.length == 0)
            return false;
        //创建ReentrantLock锁对象lock
        final ReentrantLock lock = this.lock;
        //锁
        lock.lock();
        try {
        		//将elements 数组引用指向array数组
            Object[] elements = getArray();
            int len = elements.length;
            //如果原数组为空并且cs数组所属Object数组，则直接将array指向cs数组
            if (len == 0 && cs.getClass() == Object[].class)
                setArray(cs);
            //否则将cs数组添加至尾部
            else {
                Object[] newElements = Arrays.copyOf(elements, len + cs.length);
                System.arraycopy(cs, 0, newElements, len, cs.length);
                setArray(newElements);
            }
            return true;
        } finally {
        //释放锁
            lock.unlock();
        }
    }

此方法需要传入一个Collection接口的集合对象，方法开始用Object.getClass（）方法先判断此集合和CopyOnWriteArrayList是否为同一类型，如果是直接使用getArray()方法取得数组元素赋值给cs数组，否则用toArray()方法讲集合转换为数组赋值给cs数组，如果cs数组长度为0，说明没有添加的元素，返回false，再通过getArray() 方法拿到当前array数组的值赋给elements 数组，并取得其长度len，如果len == 0 && cs.getClass() == Object[].class，说明此时array数组没有元素，将此集合转换为的数组通过setArray设置成最终数组；当len不为0时，通过Arrays.copyOf(elements, len + cs.length);得到一个扩容的数组newElements ，再通过System.arraycopy(cs, 0, newElements, len, cs.length);将新元素添加到数组尾部。

2.7 remove(int index)

 public E remove(int index) {
 				 //创建ReentrantLock锁对象lock
        final ReentrantLock lock = this.lock;
        //锁
        lock.lock();
        try {
        			//将elements 数组引用指向array数组
            Object[] elements = getArray();
            int len = elements.length;
            //得到要被删除的元素对象
            E oldValue = get(elements, index);
            //计算要移动元素的个数
            int numMoved = len - index - 1;
            //移动元素的个数为0说明删除最后一位
            if (numMoved == 0)
                setArray(Arrays.copyOf(elements, len - 1));
            //否则将少了index的元素复制进newElements，最终array指向newElements
            else {
                Object[] newElements = new Object[len - 1];
                System.arraycopy(elements, 0, newElements, 0, index);
                System.arraycopy(elements, index + 1, newElements, index,
                                 numMoved);
                setArray(newElements);
            }
            //返回删除的元素对象
            return oldValue;
        } finally {
        			//释放锁
            lock.unlock();
        }
    }

此方法与add(int index, E element)方法实现过程也是大同小异，因为是根据index删除元素，数组最后元素的下标是len-1，所以通过int numMoved = len - index - 1;获取需要移动的元素个数，其复制到新数组的方式与add(int index, E element)方法不同于它是减少容量，其他实现方式相同，最终也是通过setArray才传给array为最终数组。

2.8 removeRange(int fromIndex, int toIndex)

void removeRange(int fromIndex, int toIndex) {
				//创建ReentrantLock锁对象lock
        final ReentrantLock lock = this.lock;
        //锁
        lock.lock();
        try {.
        		//将elements 数组引用指向array数组
            Object[] elements = getArray();
            int len = elements.length;
					//如果起始范围小于0或者最终范围越界或者起始范围小于最终范围，则抛出异常
            if (fromIndex < 0 || toIndex > len || toIndex < fromIndex)
                throw new IndexOutOfBoundsException();
            //计算新数组的长度
            int newlen = len - (toIndex - fromIndex);
            //计算toIndex到len之间的元素个数
            int numMoved = len - toIndex;
            if (numMoved == 0)
                setArray(Arrays.copyOf(elements, newlen));
            else {
                Object[] newElements = new Object[newlen];
                System.arraycopy(elements, 0, newElements, 0, fromIndex);
                System.arraycopy(elements, toIndex, newElements,
                                 fromIndex, numMoved);
                setArray(newElements);
            }
        } finally {
        		//释放锁
            lock.unlock();
        }
    }

此方法与remove(int index)方法大同小异，多了一个int newlen = len - (toIndex - fromIndex);因为是根据范围删除元素，此newlen计算了删除范围元素后的数组长度，再通过int numMoved = len - toIndex;得到toIndex到len的剩余元素的个数，再与之前相同复制到newElements数组中，最终也是通过setArray才传给array为最终数组。

2.9 removeAll(Collection<?> c)

public boolean removeAll(Collection<?> c) {
				//如果c集合为空，则抛异常
        if (c == null) throw new NullPointerException();
        //创建ReentrantLock锁对象lock
        final ReentrantLock lock = this.lock;
        //锁
        lock.lock();
        try {
        			//将elements 数组引用指向array数组
            Object[] elements = getArray();
            int len = elements.length;
            if (len != 0) {
                // temp array holds those elements we know we want to keep
                int newlen = 0;
                //创建一个长度为len的Object数组len
                Object[] temp = new Object[len];
                for (int i = 0; i < len; ++i) {
                //将elements数组元素对象赋值给element 
                    Object element = elements[i];
                    //如果不包含elements数组中的对象element，则将element存入 temp[newlen++]数组中
                    if (!c.contains(element))
                        temp[newlen++] = element;
                }
                //如果newlen不等于len，说明已经删除了元素，将array指向新复制的数组，返回true
                if (newlen != len) {
                    setArray(Arrays.copyOf(temp, newlen));
                    return true;
                }
            }
            //否则返回false
            return false;
        } finally {
        		//释放锁
            lock.unlock();
        }
    }

此方法根据传入实现Collection接口的集合，在保证原数组长度不为0时，创建一个temp数组，用来存放elements数组和c集合补集的元素，也就是不将要删除的元素存入temp数组，如果newlen不等于len说明有元素删除成功，返回true，否则没有输出元素，返回false。

2.10 clear()

 public void clear() {
			 //创建ReentrantLock锁对象lock
        final ReentrantLock lock = this.lock;
        //锁
        lock.lock();
        try {
        		//初始化长度为0的数组
            setArray(new Object[0]);
        } finally {
        		//释放锁
            lock.unlock();
        }
    }

用setArray()方法讲array设置为一个长度为0的新数组，也就是清空所有元素。

2.11 sort(Comparator<? super E> c)

public void sort(Comparator<? super E> c) {
 			//创建ReentrantLock锁对象lock
        final ReentrantLock lock = this.lock;
        //锁
        lock.lock();
        try {
       		 //将elements 数组引用指向array数组
            Object[] elements = getArray();
            //将elements复制到新数组newElements
            Object[] newElements = Arrays.copyOf(elements, elements.length);
            @SuppressWarnings("unchecked") E[] es = (E[])newElements;
            //传入c接口指定排序方式将es排序
            Arrays.sort(es, c);
            //array通过引用将排序好的数组
            setArray(newElements);
        } finally {
            lock.unlock();
        }
    }

此方法需要传入一个Comparator接口的实现类对象，方法中会先按照原数组长度复制出一个相同的newElements数组，
然后通过E[] es = (E[])newElements;转换成静态数组es，通过Arrays工具类传入es数组和Comparator接口的实现类对象c，使得数组按照c中的排序逻辑排序，最终将排好序的数组通过setArray方法复制给array为最终数组。（es和newElements指向同一个地址，其是通过引用的方式用setArray方法复制给array，原因可能是逼格较高(开玩笑）

2.12 equals(Object o)

public boolean equals(Object o) {
				//如果和this相等说明是同一个对象，返回true
        if (o == this)
            return true;
        //如果o不属于List接口子类，则返回false
        if (!(o instanceof List))
            return false;
			//将o转换成List接口的实现类
        List<?> list = (List<?>)(o);
        //创建迭代器
        Iterator<?> it = list.iterator();
        //将elements 数组引用指向array数组
        Object[] elements = getArray();
        int len = elements.length;
        //for循环遍历len次
        for (int i = 0; i < len; ++i)
        //如果it没有下一个元素或则 eq方法返回值为false，则返回false
            if (!it.hasNext() || !eq(elements[i], it.next()))
                return false;
        //for循环遍历后如果it还有下一个元素，说明长度不同，返回false
        if (it.hasNext())
            return false;
        //以上都没问题则返回true    
        return true;
    }
    private static boolean eq(Object o1, Object o2) {
    		//如果o1对象为null，则o2对象为null返回ture，不为null返回false；如果o1对象不为null，则o1和o2内存地址相等返回true
        return (o1 == null) ? o2 == null : o1.equals(o2);
    }
    //==比较内存地址
    public boolean equals(Object obj) {
        return (this == obj);
    }

此方法会先判断Object对象o是否为自己，是则返回true，再判断o如果不属于List接口实现类，将会返回false；判断完成后会将o转换成List集合list，并创建出其迭代器it，获取当前数组赋值给elements 并取得其长度len，最终通过for循环遍历len次，如果遍历期间it没有下一个元素则返回false，或通过私有方法eq（）判断elements[i]对象是否为null，如果是则判断it.next()对象是否为null，如果it.next()对象不为null则返回false，如果elements[i]对象不为null则调用Object的equals()方法比较两对象的内存地址，不相等返回false。当for循环结束后，如果迭代器中it.hasNext()还有下一个元素，说明只是前面内容相同，长度不同，返回false。否则最终返回true；

2.13 hashCode()

public int hashCode() {
				//hashCode初始值为1
        int hashCode = 1;
        //将elements 数组引用指向array数组
        Object[] elements = getArray();
        int len = elements.length;
        for (int i = 0; i < len; ++i) {
        			//取出数组中的元素赋值给obj
            Object obj = elements[i];
            //如果obj为空则加0否则加上Object类的hashCode方法算出的哈希值
            hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());
        }
        return hashCode;
    }
}

此方法会遍历原数组的内容，赋值给Object对象obj再通过hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());算法算出hashCode，最终返回。（此算法hashCode初始值是1，然后通过不断用自己的hashCode*31再加上obj对象换算出的hashCode，如果obj为null，则obj的hashCode为0，否则将使用Object类的hashCode（）方法，算出obj的hashCode）

总结

通过以上源码的阅读，我们能发现在写入方法中都用了ReentrantLock对象锁，所以CopyOnWriteArrayList是线程安全的，但是只能保证数据最终的一致性；我们还能发现在对元素进行增删改的时候，并不是直接对原数组进行操作，而是通过getArray()方法取得原数组的信息赋值给elements数组，先对elements数组操作，最终才通过setArray()方法赋值回array数组，这样就可以在写入操作的时候，也可以同时进行并发的读取操作，但无法读到实时的数据信息。