深入解析 `CopyOnWriteArrayList` 的实现原理与应用

执键行天涯

已于 2024-08-22 10:18:36 修改

阅读量501

点赞数 12

分类专栏： JAVA基础文章标签： java

于 2024-08-21 15:01:32 首次发布

本文链接：https://blog.csdn.net/qq_39666711/article/details/141392744

版权

JAVA基础专栏收录该内容

8 篇文章 0 订阅

订阅专栏

在这里插入图片描述

一、什么是CopyOnWriteArrayList？

CopyOnWriteArrayList是Java并发包（java.util.concurrent）中提供的一种线程安全的可变长度的List集合，它相当于线程安全的ArrayList。CopyOnWriteArrayList通过写时复制（Copy-On-Write）的策略来实现线程安全，即在修改数据时，不是直接在原数组上进行修改，而是先复制一份原数组，然后在新的数组上进行修改，最后将原数组的引用指向新的数组。这种策略使得读操作（如get、iterator等）可以完全不加锁，从而提高了读操作的性能。

二、CopyOnWriteArrayList的工作原理
CopyOnWriteArrayList是ArrayList的一个线程安全的变体。读操作可以在不加锁的情况下进行，从而提高了并发性能。

具体来说，CopyOnWriteArrayList内部有一个可重入锁（ReentrantLock）来保证线程安全，但这个锁只在写操作时才会被使用。当进行修改操作时，线程会先获取锁，然后复制底层数组，并在新数组上执行修改。修改完成后，通过volatile关键字修饰的引用来确保新的数组对所有线程可见。由于读操作不需要获取锁，因此多个线程可以同时进行读操作，而不会相互干扰。

线程安全机制
CopyOnWriteArrayList 通过以下机制实现线程安全：

不可变性：通过维护一个不可变的数组，使读操作无须加锁。
ReentrantLock：使用重入锁（ReentrantLock）确保写操作的原子性，防止并发写操作的冲突。
volatile 关键字：确保所有线程能够看到最新的数组引用。
这种设计确保了在多线程环境下，读操作不会阻塞写操作，写操作也不会影响读操作。

性能分析
读操作
由于内部数组是不可变的，读操作非常高效，无需加锁，直接读取即可。因此，在读操作占多数的场景中，CopyOnWriteArrayList 能提供很高的性能。

写操作
写操作由于需要复制整个数组，开销较大。特别是在数组较大时，写操作的性能会受到较大影响。因此，CopyOnWriteArrayList 适用于读多写少的场景。

内存消耗
每次写操作都会创建一个新数组，这意味着在高频写操作的场景中，内存消耗会增加。因此，CopyOnWriteArrayList 在写操作频繁的情况下可能会导致较大的内存开销。

适用场景
读多写少的并发场景。
对数据一致性要求不高，可以容忍一定程度的数据延迟更新的场景。
不适合用于更新频繁的数据结构。

缺点：
1、由于写操作的时候，需要拷贝数组，会消耗内存，如果原数组的内容比较多的情况下，可能导致young gc或者full gc。（1、young gc ：年轻代（Young Generation）：对象被创建时，内存的分配首先发生在年轻代（大对象可以直接被创建在年老代），大部分的对象在创建后很快就不再使用，因此很快变得不可达，于是被年轻代的GC机制清理掉（IBM的研究表明，98%的对象都是很快消亡的），这个GC机制被称为Minor GC或叫Young GC。

2、年老代（Old Generation）：对象如果在年轻代存活了足够长的时间而没有被清理掉（即在几次Young GC后存活了下来），则会被复制到年老代，年老代的空间一般比年轻代大，能存放更多的对象，在年老代上发生的GC次数也比年轻代少。当年老代内存不足时，将执行Major GC，也叫 Full GC ）

3、不能用于实时读的场景，像拷贝数组、新增元素都需要时间，所以调用一个set操作后，读取到数据可能还是旧的,虽然CopyOnWriteArrayList 能做到最终一致性,但是还是没法满足实时性要求；

1、add(E e) ：将指定元素添加到此列表的尾部，返回值为boolean。

2、add(int index, E element) : 在此列表的指定位置上插入指定元素。

3、clear()：从此列表移除所有元素。

4、contains(Object o) ：如果此列表包含指定的元素，则返回 true。

5、equals(Object o) ：比较指定对象与此列表的相等性。

6、get(int index) ： 返回列表中指定位置的元素。
7、hashCode() ： 返回此列表的哈希码值。

8、indexOf(E e, int index) ： 返回第一次出现的指定元素在此列表中的索引，从 index 开始向前搜索，如果没有找到该元素，则返回 -1。

9、indexOf(Object o) ：返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。

10、isEmpty() ：如果此列表不包含任何元素，则返回 true。

11、iterator() ：返回以恰当顺序在此列表元素上进行迭代的迭代器，返回值为 Iterator。

12、lastIndexOf(E e, int index) ：返回最后一次出现的指定元素在此列表中的索引，从 index 开始向后搜索，如果没有找到该元素，则返回 -1。

13、lastIndexOf(Object o) ： 返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。

14、remove(int index) ：移除此列表指定位置上的元素。

15、remove(Object o) ：从此列表移除第一次出现的指定元素（如果存在），返回值为 boolean。

16、set(int index, E element) ：用指定的元素替代此列表指定位置上的元素。

17、size() ：返回此列表中的元素数。

18、subList(int fromIndex, int toIndex) ：返回此列表中 fromIndex（包括）和 toIndex（不包括）之间部分的视图，返回值为 List 。

示例：

package chapter3.copyonwrite;
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;
/**
 * @author czd
 */
public class CopyOnWriteArrayListTest {
    public static void main(String[] args) {
        /**
         * 构造方法摘要
         * CopyOnWriteArrayList()：
         *           创建一个空列表。
         * CopyOnWriteArrayList(Collection<? extends E> c)：
         *           创建一个按 collection 的迭代器返回元素的顺序包含指定 collection 元素的列表。
         * CopyOnWriteArrayList(E[] toCopyIn)：
         *           创建一个保存给定数组的副本的列表。
         */
        /**
         * 1、add(E e) :将指定元素添加到此列表的尾部,返回值为boolean。
         *
         * 2、iterator() :返回以恰当顺序在此列表元素上进行迭代的迭代器,返回值为Iterator<E>。
         */
        CopyOnWriteArrayList<Integer> copyOnWriteArrayList = new CopyOnWriteArrayList<>();
        Boolean addBoolean = copyOnWriteArrayList.add(1);
        System.out.println("是否添加到此列表的尾部?" + addBoolean);
        Iterator<Integer> iterator = copyOnWriteArrayList.iterator();
        while (iterator.hasNext()){
            System.out.println("iterator的结果: " + iterator.next());
        }
        /**
         * 3、add(int index, E element) :在此列表的指定位置上插入指定元素。
         */
        CopyOnWriteArrayList<Integer> copyOnWriteArrayList1 = new CopyOnWriteArrayList<>();
        copyOnWriteArrayList1.add(1);
        copyOnWriteArrayList1.add(2);
        copyOnWriteArrayList1.add(2,5);
//        copyOnWriteArrayList1.add(4,6);
        System.out.println("index = 0 的值为：" + copyOnWriteArrayList1.get(0));
        System.out.println("index = 1 的值为：" + copyOnWriteArrayList1.get(1));
        System.out.println("index = 2 的值为：" + copyOnWriteArrayList1.get(2));
//        System.out.println("index = 4 的值为：" + copyOnWriteArrayList1.get(4));
        /**
         * 注意：如果使用add(int index, E element),必须保证index的前面的index存在值，不然会报错。
         *      （可以把上两行注释去掉，运行试试结果）
         */
        /**
         * 4.1、indexOf(E e, int index)
         *           返回第一次出现的指定元素在此列表中的索引，从 index 开始向前搜索，如果没有找到该元素，则返回 -1。
         * 4.2、indexOf(Object o)
         *           返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
         */
        CopyOnWriteArrayList<Integer> copyOnWriteArrayList2 = new CopyOnWriteArrayList<>();
        copyOnWriteArrayList2.add(1);
        copyOnWriteArrayList2.add(2);
        copyOnWriteArrayList2.add(3);
        Integer indexFirst = copyOnWriteArrayList2.indexOf(2);
        System.out.println("2的index为：" + indexFirst);
        /**
         * 5.1、lastIndexOf(E e, int index)
         *           返回最后一次出现的指定元素在此列表中的索引，从 index 开始向后搜索，如果没有找到该元素，则返回 -1。
         * 5.2、lastIndexOf(Object o)
         *           返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
         */
        CopyOnWriteArrayList<Integer> copyOnWriteArrayList3 = new CopyOnWriteArrayList<>();
        copyOnWriteArrayList3.add(1);
        copyOnWriteArrayList3.add(2);
        copyOnWriteArrayList3.add(3);
        copyOnWriteArrayList3.add(3);
        copyOnWriteArrayList3.add(4);
        Integer lastIndexOf = copyOnWriteArrayList3.lastIndexOf(3);
        System.out.println("列表中最后出现的指定元素的索引: " + lastIndexOf);
        /**
         * 6、remove(int index) ：移除此列表指定位置上的元素,并且此下标后面的值会进一位，
         *                      即index为1的值被remove掉，index为2的值就变为index为1的值。
         */
        CopyOnWriteArrayList<Integer> copyOnWriteArrayList4 = new CopyOnWriteArrayList<>();
        copyOnWriteArrayList4.add(5);
        copyOnWriteArrayList4.add(6);
        copyOnWriteArrayList4.add(7);
        copyOnWriteArrayList4.add(8);
        Integer removeResult = copyOnWriteArrayList4.remove(1);
        System.out.println("copyOnWriteArrayList4索引为1的值：" + removeResult);
        System.out.println("copyOnWriteArrayList4中是否还存在索引为1的值：" + copyOnWriteArrayList4.get(1));
        /**
         * 7、remove(Object o) ：从此列表移除第一次出现的指定元素（如果存在）。
         */
        CopyOnWriteArrayList<String> copyOnWriteArrayList5 = new CopyOnWriteArrayList<>();
        copyOnWriteArrayList5.add("5");
        copyOnWriteArrayList5.add("6");
        copyOnWriteArrayList5.add("6");
        copyOnWriteArrayList5.add("7");
        copyOnWriteArrayList5.add("7");
        System.out.println("没被remove前的size: " + copyOnWriteArrayList5.size());
        Boolean removeBoolean = copyOnWriteArrayList5.remove("7");
        System.out.println("copyOnWriteArrayList5是否移除7成功？" + removeBoolean);
        System.out.println("index为3的值为：" + copyOnWriteArrayList5.get(3));
        System.out.println("被remove后的size: " + copyOnWriteArrayList5.size());
        /**
         * 8、set(int index, E element) ：用指定的元素替代此列表指定位置上的元素。
         */
        CopyOnWriteArrayList<String> copyOnWriteArrayList6 = new CopyOnWriteArrayList<>();
        copyOnWriteArrayList6.add("1");
        copyOnWriteArrayList6.add("2");
        copyOnWriteArrayList6.add("3");
        copyOnWriteArrayList6.add("4");
        copyOnWriteArrayList6.add("5");
        System.out.println("没使用set()方法前，index = 1 的值为：" + copyOnWriteArrayList6.get(1));
        copyOnWriteArrayList6.set(1,"czd");
        System.out.println("使用set()方法后，index = 1 的值为：" + copyOnWriteArrayList6.get(1));
    }
}

参考链接：https://blog.csdn.net/qq_44624290/article/details/140046183

执键行天涯

关注

12
点赞
踩
12

收藏

觉得还不错? 一键收藏
打赏
0
评论
深入解析 `CopyOnWriteArrayList` 的实现原理与应用

1、由于写操作的时候，需要拷贝数组，会消耗内存，如果原数组的内容比较多的情况下，可能导致young gc或者full gc。（1、young gc ：年轻代（Young Generation）：对象被创建时，内存的分配首先发生在年轻代（大对象可以直接被创建在年老代），大部分的对象在创建后很快就不再使用，因此很快变得不可达，于是被年轻代的GC机制清理掉（IBM的研究表明，98%的对象都是很快消亡的），这个GC机制被称为Minor GC或叫Young GC。特别是在数组较大时，写操作的性能会受到较大影响。
复制链接

扫一扫