Java并发集合之CopyOnWriteArrayList使用与原理

最新推荐文章于 2024-04-27 09:13:51 发布
最新推荐文章于 2024-04-27 09:13:51 发布
阅读量741 收藏
点赞数 1
分类专栏： Java并发集合JUC 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wlove514/article/details/130110663
版权

CopyOnWriteArrayList简介

CopyOnWriteArrayList是线程安全的可变长度的List集合，相当于线程安全的ArrayList。
线程安全与线程不安全的区别：

  • 线程安全：多个线程同时读写该集合时不会发生ConcurrentModificationException的异常
  • 线程不安全：多个线程同时读写集合是会发生ConcurrentModificationException异常

CopyOnWriteArrayList的特性

  • 适用于数据量较小且读多写少的场景
  • 它是线程安全的
  • 新增和删除等修改数据的操作开销很大，涉及到数组复制后续源码解析会详解
  • 迭代器只支持读取不支持变更，并且在迭代过程中其他线程写入集合不会发生并发冲突

CopyOnWriteArrayList的数据结构

  • CopyOnWriteArrayList底层也是通过数组来实现的，每次新增或删除数据都会通过拷贝数组的方式实现动态变更，源码定义如下
private transient volatile Object[] array;
  • volatile关键字用于在多线程操作中可以拿到最新的数组数据

CopyOnWriteArrayList的部分源码解析

构造方法

  • 无参构造方法，创建一个空数组
final Object[] getArray() {
        return array;
    }
final void setArray(Object[] a) {
        array = a;
    }
public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }
  • 有参构造方法，通过数组拷贝将参数中的数组或者集合拷贝到私有属性的array中
public CopyOnWriteArrayList(Collection<? extends E> c) {
        Object[] elements;
        if (c.getClass() == CopyOnWriteArrayList.class)
            elements = ((CopyOnWriteArrayList<?>)c).getArray();
        else {
            elements = c.toArray();
            if (c.getClass() != ArrayList.class)
                elements = Arrays.copyOf(elements, elements.length, Object[].class);
        }
        setArray(elements);
    }
public CopyOnWriteArrayList(E[] toCopyIn) {
        setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
    }

变更数据方法

  • add方法
public boolean add(E e) {
		// 获取当前实例的可重入锁
        final ReentrantLock lock = this.lock;
        // 阻塞式加锁
        lock.lock();
        try {
            // 获取当前集合的底层数组
            Object[] elements = getArray();
            int len = elements.length;
            // 将当前数组的全部数据拷贝到新数组中，新数组长度为当前长度+1
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            // 设置新增数据到数组中
            newElements[len] = e;
            // 将当前实例的底层数组指向新数组
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

这里可以解释为什么称为CopyOnWrite的原因，因为在写入数据的时候会创建一个新的数组，将原数组的数据进行拷贝后再替换原数组，这也是在进行新增数据的时候会开销很大的原因

  • 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();
        }
    }
  • 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];
                System.arraycopy(elements, 0, newElements, 0, index);
                System.arraycopy(elements, index + 1, newElements, index,
                                 numMoved);
                setArray(newElements);
            }
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

CopyOnWriteArrayList变更数据总结：

  • 不管是新增、修改还是删除一个元素，都需要重建数组并且拷贝原数组的全部数据，因此CopyOnWriteArrayList在做数据变更的时候会有更大的资源开销
  • 在数据变更操作是会加上当前实例的ReentrantLock锁保证线程安全
  • 不会出现ConcurrentModificationException异常的原因是读取线程拿到的数组对象与写入线程拿到的数组对象其实是两个不同的对象，因此不会出现该异常
    这里列举的是几个比较简单的数据变更方法，其他的数据变更方法原理是一样的，有兴趣可以自己翻一下源码了解一下

迭代器方法

  • iterator方法
public Iterator<E> iterator() {
        return new COWIterator<E>(getArray(), 0);
    }
  • COWIterator类的变更方法
public void remove() {
            throw new UnsupportedOperationException();
        }

        /**
         * Not supported. Always throws UnsupportedOperationException.
         * @throws UnsupportedOperationException always; {@code set}
         *         is not supported by this iterator.
         */
        public void set(E e) {
            throw new UnsupportedOperationException();
        }

        /**
         * Not supported. Always throws UnsupportedOperationException.
         * @throws UnsupportedOperationException always; {@code add}
         *         is not supported by this iterator.
         */
        public void add(E e) {
            throw new UnsupportedOperationException();
        }

CopyOnWriteArrayList的迭代器方法会构造一个COWIterator对象，在该类的实现中所有变更记录的方法都会抛出UnsupportedOperationException，因此在CopyOnWriteArrayList的迭代器方法中只能读取数据不能对数据进行变更操作

一个实例对比CopyOnWriteArrayList和ArrayList

  • 公共类
private static void printAll(List<String> list) {
        System.out.println(list);
    }

    static class ListRunnable implements Runnable {

        private final List<String> list;

        ListRunnable(List<String> list) {
            this.list = list;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                list.add(Thread.currentThread().getName() + "-" + i);
                printAll(list);
            }
        }
    }
  • 多线程操作ArrayList
@Test
    public void notUseJuc() throws InterruptedException {
        List<String> list = new ArrayList<>();
        final Thread th1 = new Thread(new ListRunnable(list));
        final Thread th2 = new Thread(new ListRunnable(list));

        th1.start();
        th2.start();
        th2.join();
    }

运行结果会偶发异常：

[Thread-0-0, Thread-1-0]
[Thread-0-0, Thread-1-0, Thread-1-1]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-1-2]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-1-2, Thread-1-3]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-1-2, Thread-1-3, Thread-1-4]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-1-2, Thread-1-3, Thread-1-4, Thread-1-5]
Exception in thread "Thread-0" java.util.ConcurrentModificationException
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-1-2, Thread-1-3, Thread-1-4, Thread-1-5, Thread-1-6]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-1-2, Thread-1-3, Thread-1-4, Thread-1-5, Thread-1-6, Thread-1-7]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-1-2, Thread-1-3, Thread-1-4, Thread-1-5, Thread-1-6, Thread-1-7, Thread-1-8]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-1-2, Thread-1-3, Thread-1-4, Thread-1-5, Thread-1-6, Thread-1-7, Thread-1-8, Thread-1-9]
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:911)
	at java.util.ArrayList$Itr.next(ArrayList.java:861)
	at java.util.AbstractCollection.toString(AbstractCollection.java:461)
	at java.lang.String.valueOf(String.java:2994)
	at java.io.PrintStream.println(PrintStream.java:821)
	at com.bufan.juc.JucListTest.printAll(JucListTest.java:38)
	at com.bufan.juc.JucListTest.access$000(JucListTest.java:13)
	at com.bufan.juc.JucListTest$ListRunnable.run(JucListTest.java:53)
	at java.lang.Thread.run(Thread.java:748)
  • 多线程操作CopyOnWriteArrayList
@Test
    public void useJuc() throws InterruptedException {
        List<String> list = new CopyOnWriteArrayList<>();
        final Thread th1 = new Thread(new ListRunnable(list));
        final Thread th2 = new Thread(new ListRunnable(list));

        th1.start();
        th2.start();
        th2.join();
    }

运行结果正常，不会抛ConcurrentModificationException异常：

[Thread-0-0, Thread-1-0]
[Thread-0-0, Thread-1-0]
[Thread-0-0, Thread-1-0, Thread-1-1]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-0-1]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-0-1, Thread-1-2]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-0-1, Thread-1-2, Thread-0-2]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-0-1, Thread-1-2, Thread-0-2, Thread-1-3]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-0-1, Thread-1-2, Thread-0-2, Thread-1-3, Thread-0-3]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-0-1, Thread-1-2, Thread-0-2, Thread-1-3, Thread-0-3, Thread-1-4]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-0-1, Thread-1-2, Thread-0-2, Thread-1-3, Thread-0-3, Thread-1-4, Thread-0-4]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-0-1, Thread-1-2, Thread-0-2, Thread-1-3, Thread-0-3, Thread-1-4, Thread-0-4, Thread-1-5]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-0-1, Thread-1-2, Thread-0-2, Thread-1-3, Thread-0-3, Thread-1-4, Thread-0-4, Thread-1-5, Thread-0-5]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-0-1, Thread-1-2, Thread-0-2, Thread-1-3, Thread-0-3, Thread-1-4, Thread-0-4, Thread-1-5, Thread-0-5, Thread-1-6]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-0-1, Thread-1-2, Thread-0-2, Thread-1-3, Thread-0-3, Thread-1-4, Thread-0-4, Thread-1-5, Thread-0-5, Thread-1-6, Thread-0-6]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-0-1, Thread-1-2, Thread-0-2, Thread-1-3, Thread-0-3, Thread-1-4, Thread-0-4, Thread-1-5, Thread-0-5, Thread-1-6, Thread-0-6, Thread-1-7]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-0-1, Thread-1-2, Thread-0-2, Thread-1-3, Thread-0-3, Thread-1-4, Thread-0-4, Thread-1-5, Thread-0-5, Thread-1-6, Thread-0-6, Thread-1-7, Thread-0-7]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-0-1, Thread-1-2, Thread-0-2, Thread-1-3, Thread-0-3, Thread-1-4, Thread-0-4, Thread-1-5, Thread-0-5, Thread-1-6, Thread-0-6, Thread-1-7, Thread-0-7, Thread-1-8]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-0-1, Thread-1-2, Thread-0-2, Thread-1-3, Thread-0-3, Thread-1-4, Thread-0-4, Thread-1-5, Thread-0-5, Thread-1-6, Thread-0-6, Thread-1-7, Thread-0-7, Thread-1-8, Thread-0-8]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-0-1, Thread-1-2, Thread-0-2, Thread-1-3, Thread-0-3, Thread-1-4, Thread-0-4, Thread-1-5, Thread-0-5, Thread-1-6, Thread-0-6, Thread-1-7, Thread-0-7, Thread-1-8, Thread-0-8, Thread-1-9]
[Thread-0-0, Thread-1-0, Thread-1-1, Thread-0-1, Thread-1-2, Thread-0-2, Thread-1-3, Thread-0-3, Thread-1-4, Thread-0-4, Thread-1-5, Thread-0-5, Thread-1-6, Thread-0-6, Thread-1-7, Thread-0-7, Thread-1-8, Thread-0-8, Thread-1-9, Thread-0-9]
不烦来了
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 多线程与并发(14-26)-JUC集合- CopyOnWriteArrayList详解.pdf
07-27
Java 多线程与并发(14_26)-JUC集合_ CopyOnWriteArrayList详解
CopyOnWriteArrayList 源码解析和设计思路
xzh109的博客
02-18 477
引导语 在 ArrayList 的类注释上，JDK 就提醒了我们，如果要把 ArrayList 作为共享变量的话，是线程不安全的，推荐我们自己加锁或者使用 Collections.synchronizedList 方法，其实 JDK 还提供了另外一种线程安全的 List，叫做 CopyOnWriteArrayList，这个 List 具有以下特征： 线程安全的，多线程环境下可以直接使用，无需加锁...
CopyOnWriteArrayList底层原理全面解析【建议收藏】
专注Java后端技术干货、项目源码总结分享，期待您的关注。
02-07 1229
CopyOnWriteArrayList是Java中的一个线程安全的集合类，是ArrayList线程安全版本，主要通过Copy-On-Write（写时复制，简称COW）机制来保证线程安全。 Copy-On-Write机制核心思想：向一个数组中添加数据时，不直接操作原始数组，而是拷贝原始数组生成一份原始数组副本，将需要添加的数据添加到原始数组副本中，操作完成后再用原始数组副本直接替换原始数组，从而保证多个线程同时操作原始数组时的线程安全。
java集合-CopyOnWriteArrayList的使用
06-14
在Java中，CopyOnWriteArrayList（写入时复制数组列表）是线程安全的集合类，它实现了List接口，并使用了"写入时复制"的策略来保证线程安全性。 CopyOnWriteArrayList的主要特点是：在进行修改操作（例如添加、修改、删除元素）时，它会创建一个新的底层数组的副本进行修改，而不是直接修改原始数组。这样，在并发修改时，可以避免读取和写入同时进行，从而避免了传统ArrayList的线程同步问题。
Java---CopyOnWriteArrayList详解
m0_58196614的博客
08-25 1580
CopyOnWriteArrayList是ArrayList的线程安全版本，从他的名字可以推测。CopyOnWriteArrayList是在有写操作的时候会copy一份数据，然后写完再设置成新的数据。CopyOnWriteArrayList适用于读多写少的并发场景。
深度解析CopyOnWriteArrayList，线程安全的ArrayList
Sicimike的博客
12-04 2357
前言 ArrayList是线程不安全的，这点毋庸置疑。因为ArrayList的所有方法既没有加锁，也没有进行额外的线程安全处理。而Vector作为线程安全版的ArrayList，存在感总是比较低。因为无论是add、remove还是get方法都加上了synchronized锁，所以效率低下。 JDK1.5引入的J.U.C包中，又实现了一个线程安全版的ArrayList——CopyOnWriteArr...
java CopyOnWriteArrayList详解
li_w_ch的博客
01-15 4153
Java并发包中的并发list只有CopyOnWriteArrayList。CopyOnWriteArrayList是一个线程安全的ArrayList，对其进行的修改操作都是在底层的一个复制数组（快照）上进行的，也就是使用了写时复制策略。 写时复制(CopyOnWrite，简称COW)思想是计算机程序涉及领域中的一种优化策略。其核心思想是，如果多个调用者(Callers）同时要求相同的资源（如内存或者磁盘上的数据存储），他们会共同获取相同的指针指向相同的资源，直到某个调用者视图修改资源内容时，系统才会真正
【JAVA集合篇】CopyOnWriteArrayList详解
初念初恋的博客
06-17 1498
CopyOnWriteArrayList是ArrayList的线程安全版本，内部也是通过数组实现，每次对数组的修改都完全拷贝一份新的数组来修改，修改完了再替换掉老数组，这样保证了只阻塞写操作，不阻塞读操作，实现读写分离。CopyOnWriteArrayList使用重入锁加锁，保证线程安全；CopyOnWriteArrayList的写操作都要先拷贝一份新数组，在新数组中做修改，修改完了再用新数组替换老数组，所以空间复杂度是O(n)，性能比较低下；
CopyOnWriteArrayList详解
Yi_Lu_Xiang_qian的博客
05-08 143
1. 并发调⽤场景下CopyOnWriteArrayList添加元素是如何保证线程安全？ 源码解析 /**被volatile关键字修饰，保证这个数组的有序性。 */ private transient volatile Object[] array; public boolean add(E e) { final ReentrantLock lock = this.lock; // 加锁 lock.lock(); try { // 获取原有数组元素 Object[] elements
CopyOnWriteArrayList源码分析
仙草不加料的博客
09-18 211
CopyOnWriteArrayList是一个线程安全的集合，当我们对集合容器使用增删改操作时，并不是直接对方法进行加锁，在原集合进行操作，而是通过复制出一个新集合，然后在新集合中进行操作，操作结束后，将原集合容器的引用指向新的集合容器，所以他能实现写入时的线程安全，但不影响并发的读取操作，所以适用于读多写少的场景，是一种读写分离的思想。但是由于每个操作都需要拷贝原集合，数据较大的时候容易引起频繁Full GC；而且写和读在不同的Object[]数组上，容易引起数据不一致的问题。
Java并发编程：Copy-On-Write机制详解
一名Java语言狂热分子。
05-02 1368
在多线程并发访问共享数据时，可能会出现并发问题导致程序崩溃、数据异常等情况。为了避免这些问题，Java中提供了多种并发控制方法，其中Copy-On-Write（COW）机制就是一种常用的技术。本文将详细介绍COW机制的概念、如何保证线程安全、相对于锁机制的优势，并且介绍CopyOnWriteArrayList集合的原理。Copy-On-Write机制，顾名思义，就是在写入数据时进行复制，从而保证原始数据不受修改的影响。在Java中，它被广泛应用于各类集合类的实现。
并发容器和线程池，java并发编程3
最新发布
04-29
类，来感受⼀下JDK⾃带的并发集合带来的“快感”。 ConcurrentLinkedQueue是⼀个基于链接节点的⽆界线程安全队列，它采⽤先进先出的规则对节点 进⾏排序，当我们添加⼀个元素的时候，它会添加到队列的尾部，当我们...
Java并发编程基础.pdf
04-19
并发集合：熟悉Java提供的并发集合类，如ConcurrentHashMap、CopyOnWriteArrayList等，这些集合类在并发环境下提供了线程安全的操作。 线程池：了解Java中的线程池概念，如ExecutorService和ThreadPoolExecutor，...
Java多线程和并发知识整理
05-18
一、理论基础 ... 6.3 并发集合 6.4 原子类 6.5 线程池 七、BlockingQueue 八、ConcurrentHashMap 九、CopyOnWriteArrayList 十、原子类-CAS, Unsafe和原子类详解 十一、JUC锁: LockSupport详解
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 751
都是符合我们的预期的。
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 827
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
string模拟实现
m0_73969414的博客
04-23 1742
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 1024
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
PageHelper实现分页查询
m0_63849044的博客
04-24 1064
这行代码是在使用 MyBatis Generator (MBG) 或类似的 MyBatis 工具生成的代码来构建查询条件。（可能是MyBatis的Mapper接口）来执行基于前面定义的查询条件的查询，并获取结果列表。实例之后会被用来设置各种查询条件，如字段的等于、不等于、大于、小于、模糊查询等。实体类生成的辅助类，它通常包含了一些静态内部类和方法，用于构建查询条件。在MyBatis中，这样的对象通常用于构建查询条件。对象，可能用于作为查询条件）。的一个内部类，用于定义查询的具体条件。
java的集合框架原理
05-23
Java集合框架是Java提供的一组接口和类，用来处理集合数据（例如数组、列表、队列、栈等）。其实现原理主要包括以下几个方面： 1. 接口定义：Java集合框架中定义了一些接口，如List、Set、Map等。这些接口提供了不同类型集合的基本操作，如添加、删除、遍历等。每个接口都有对应的实现类。 2. 实现类：Java集合框架提供了许多实现类，如ArrayList、LinkedList、HashSet、HashMap等。这些实现类实现了对应的接口，并提供了具体的数据结构和算法实现。 3. 泛型：Java集合框架使用泛型来保证类型安全。通过使用泛型，集合框架可以对元素类型进行检查，避免了类型转换和类型错误的问题。 4. 迭代器：Java集合框架提供了迭代器来遍历集合中的元素。迭代器可以确保遍历顺序和元素数量的正确性。 5. 自动装箱和拆箱：Java集合框架提供了自动装箱和拆箱功能，可以自动将基本数据类型转换为对应的包装类对象，或者反过来。 6. 并发性：Java集合框架提供了一些线程安全的集合类，如ConcurrentHashMap、CopyOnWriteArrayList等，可以在多线程环境下使用。 总之，Java集合框架提供了一种高效、灵活、可扩展的方式来处理集合数据，并且具有良好的类型安全性和线程安全性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值