CopyOnWriteArrayList源码分析

最新推荐文章于 2022-09-15 13:45:19 发布
最新推荐文章于 2022-09-15 13:45:19 发布
阅读量208 收藏
点赞数
分类专栏： 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u7Ckm/article/details/105569948
版权

CopyOnWriteArrayList源码分析

作用

CopyOnWriteArrayList(Copy-On-Write: 写入时复制)是一个线程安全的ArrayList，对其进行的修改操作都是先加锁然后在底层的一个复制数组上进行。

优点: 经常被用于"读多写少"的并发场景，因为读取的时候不需要加锁，性能较好。读写分离，在使用迭代器迭代的时候不会抛出异常

缺点: 需要拷贝原数据，数据较大的时候容易引起频繁Full GC；写和读在不同的数组上，读取的是老数组的数据(弱一致性问题)

成员变量

// 独占锁
final transient ReentrantLock lock = new ReetrantLock(); 

// 只能通过getArray/setArray方法来获取/修改array
private transient volatile Object[] array;

初始化

1. 创建空链表

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

2. 根据给定的集合数据创建链表

public CopyOnWriteArrayList(Collections<? extends E> c) {
    Object[] elements;
    // 如果是CopyOnWriteArrayList类，直接引用
    if (c.getClass() == CopyOnWriteArrayList.class) {
        elements = ((CopyOnWriteArrayList<?>)c).getArray();
    } else {
        elements = c.toArray();
        // c.toArray可能不会返回Object[]类型
        if (elements.getClass() != Object[].class) {
            // 通过Arrays.copyOf复制数组
            elements = Arrays.copyOf(elements, elements.length, Object[].class);
        }
    }
    // 设置array变量为elements
    setArray(elements);
}

3. 根据数组创建链表

public CopyOnWriteArrayList(E[] toCopyIn) {
    // 上面方法的简化
    setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
}

获取元素

get(int index)

获取array[index]位置的值

**注意: **这里假设一个情景：将get分为两步: 1. 获取array、2. 读取指定下标的值。在线程x执行完第一步还未执行第二步时，线程y对链表进行了修改，那么get方法返回的还是未修改数组里对应的值。

因为对数组的修改操作都是需要加锁之后对数组进行拷贝，对拷贝数组操作后再修改array指向拷贝数组，但是此时线程x已经将getArray()获取到的数组(原数组)压入方法栈中，因此使用的是原数组的引用，即时线程y将array指向了拷贝数组也不影响原数组

public E get(int index) {
    return get(getArray(), index);
}

修改

set(int index, E element)

修改array[index]的值

public E set(int index, E element) {
    final ReentrantLock lock = this.lock;
    // 加锁
    lock.lock();
    try {
        // 拿到成员变量array
        Object[] elements = getArray();
        // 获取elements[index]的值
        E oldValue = get(elements, index);
		// 如果值发生了变化
        if (oldValue != element) {
        	int len = elements.length;
            // 先对elements复制一个拷贝
            Object[] newElements = Arrays.copyOf(elements, len);
            // 更新值
            newElements[index] = element;
            // 更新this.array = newElements
            setArray(newElements);
        } else {
            // 为了保证volatile语义 
            setArray(elements);
        }
        // 返回原始值
        return oldValue;
    } finally {
        // 释放锁
        lock.unlock();
    }
}

添加

add(E e)

添加元素到末尾

// 和上面的set差不多 流程: 先获取锁->拷贝数组->修改拷贝数组->修改原始数组引用
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;
        // 修改array引用
        setArray(newElements);
        return true;
    } finally {
        // 释放锁
        lock.unlock();
    }
}

删除

remove(int index)

删除index位置的值

public E remove(int index) {
    final ReentrantLock lock = this.lock;
    // 加锁
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        // index位置的值
        E oldValue = get(elements, index);
        // index之后需要移动的元素个数
        int numMoved = len - index - 1;
        // 不需要移动
        if (numMoved == 0)
            setArray(Arrays.copyOf(elements, len - 1));
        else {
            // 创建新数组
            Object[] newElements = new Object[len - 1];
            // 拷贝删除位置前面的元素
            System.arraycopy(elements, 0, newElements, 0, index);
            // 拷贝删除元素后面的元素
            System.arraycopy(elements, index + 1, newElements, index,
                                numMoved);
            // 修改array引用
            setArray(newElements);
        }
        return oldValue;
    } finally {
        lock.unlock();
    }
}
remove(Object o, Object[] snapshot, int index)
private boolean remove(Object o, Object[] snapshot, int index) {
    final ReentrantLock lock = this.lock;
    // 加锁
    lock.lock();
    try {
        Object[] current = getArray();
        int len = current.length;
        if (snapshot != current) findIndex: {
            int prefix = Math.min(index, len);
            for (int i = 0; i < prefix; i++) {
                if (current[i] != snapshot[i] && eq(o, current[i])) {
                    index = i;
                    break findIndex;
                }
            }
            if (index >= len)
                return false;
            if (current[index] == o)
                break findIndex;
            index = indexOf(o, current, index, len);
            if (index < 0)
                return false;
        }
        Object[] newElements = new Object[len - 1];
        System.arraycopy(current, 0, newElements, 0, index);
        System.arraycopy(current, index + 1,
                        newElements, index,
                        len - index - 1);
        setArray(newElements);
        return true;
   } finally {
        lock.unlock();
    }
}

迭代器

迭代器和get读取一样，如果读的过程中其他线程对数据进行了修改，仍然读取老数据的值

public Iterator<E> iterator() {
    // 返回的是COWIterator的实例
    return new COWIterator<E>(getArray(), 0);
}

接下来看COWIterator的具体实现

static final class COWIterator<E> implements ListIterator<E> {
   
    // 数组的拷贝
    private final Object[] snapshot;
    // 当前下标
    private int cursor;

    // 这里可以参考get(int index)方法
    // 在调用完getArray()方法后已经将原数组的引用压入到当前线程的栈中，其他线程是将array指向其他数组，对原始数组并没修改
    private COWIterator(Object[] elements, int initialCursor) {
        cursor = initialCursor;
        snapshot = elements;
    }

    public boolean hasNext() {
        return cursor < snapshot.length;
    }

    public boolean hasPrevious() {
        return cursor > 0;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        if (! hasNext())
            throw new NoSuchElementException();
        return (E) snapshot[cursor++];
    }

    @SuppressWarnings("unchecked")
    public E previous() {
        if (! hasPrevious())
            throw new NoSuchElementException();
        return (E) snapshot[--cursor];
    }

    public int nextIndex() {
        return cursor;
    }

    public int previousIndex() {
        return cursor-1;
    }

    // add set remove三个操作均不支持    
    public void remove() {
        throw new UnsupportedOperationException();
    }

        
    public void set(E e) {
        throw new UnsupportedOperationException();
    }

       
    public void add(E e) {
        throw new UnsupportedOperationException();
    }
}

使用场景

假如我们有一个搜索的网站需要屏蔽一些“关键字”，“黑名单”每晚凌晨定时更新，每当用户搜索的时候，“黑名单”中的关键字不会出现在搜索结果当中，并且提示用户敏感字。

这里因为凌晨接口被访问的可能性低，CopyOnWriteArrayList只能保证数据最终一致，只要在修改数据的时候没有被读取即可

参考

  1. 深入浅出Java多线程 16 CopyOnWriteList
  2. 《Java并发编程之美》
uzck
关注
专栏目录
CopyOnWriteArrayList浅析
听风的专栏
06-28 505
CopyOnWriteArrayList的特点与用法 CopyOnWriteArrayList的数据结构 CopyOnWriteArrayList的常用方法及实现 CopyOnWriteArrayList的特点与用法CopyOnWriteArrayList的数据结构和用法与ArrayList基本都相同,区别主要在于CopyOnWriteArrayList在添加和删除元素等修改集合状态的操作时，都会重
java中remove(int index)和remove(Object o)的易错点
blog
03-14 693
问题 今天做一道题，用到两个指定Integer泛型类型的LinkedList(list1,list2)，先取出list1中下标为index1的元素，把这个元素作为list2链表的下标(index2)，再删除list2中下标为index2的元素。一开始想的代码是这样的： list2.remove(list1.get(index1));//index2相当于list1.get(index1) 突然想到，list1.get(index1)的返回值是Integer类型，这样传入list2.remove()的类型就
ArrayList为什么不能在for里面删除而CopyOnWriteArrayList可以
gbh666666的博客
12-20 414
首先说一点 就是 CopyOnWriteArrayList 支持在for循环里面直接删除 上源码 private boolean remove(Object o, Object[] snapshot, int index) { //可重入锁 final ReentrantLock lock = this.lock; lock.lock(); ...
CopyOnWriteArrayList是如何保证线程安全的？
m0_73311735的博客
09-15 668
首先是加锁，同样也是将原数组分为两段进行操作，根据index进行分隔，分别copy index之前的元素和之后的元素，copy到一个新数组中，新数组的长度为原数组的长度减一（注意这里是没有copy index索引位置的值的，所以相当于移除了index索引上的值）。首先加锁，然后通过Arrays.copyOf()方法将元素copy到一个新的数组中，新的数组的长度为原数组的长度+1，并且将需要加入的元素赋值到新数组的最后。将传入的数组的元素copy到一个新的Object数组，并且赋值给成员变量array。
CopyOnWriteArrayList（遍历中删除元素）
myk_msrry的博客
07-31 3953
CopyOnWriteArrayList 在之前的像素鸟游戏中我遇到一个问题，我想要在遍历List的同时根据一定条件删除List中的元素。 但是有一个问题，我们不能在遍历一个List的同时对于其内的元素进行删改的操作。 这时候会给出这样的错误： java.util.ConcurrentModificationException 我不想使用迭代的方式完成这个功能，那样很麻烦，难道我不能使用List把这个问题解决么？ 这个时候我了解了一个List的实现类CopyOnWriteArrayList。 public
Java8 CopyOnWriteArrayList 源码分析
点滴记录
02-15 551
一、CopyOnWriteArrayList 概述 1.1 概念概述 CopyOnWriteArrayList 是 juc 包下一个线程安全的并发容器，底层使用数组实现。CopyOnWrite 顾名思义是写时复制的意思，其基本思路是，从一开始大家都在共享同一个内容，当某个人想要修改这个内容的时候，会把内容 Copy 出去形成一个新的内容然后再进行修改，这是一种延时懒惰策略。 假设往一个容器添加元素...
Copy-On-Write读写分离策略和CopyOnWriteArrayList源码分析
jjkang的博客
08-31 1247
Copy-On-Write简称COW，是一种用于程序设计的优化策略。JDK有两种Copy-On-Write容器，CopyOnWriteArrayList和CopyOnWriteArraySet。
java并发容器CopyOnWriteArrayList实现原理及源码分析
08-30
Java并发容器CopyOnWriteArrayList实现原理及源码分析 Java并发容器CopyOnWriteArrayList是Java并发包中提供的一个并发容器，实现了线程安全且读操作无锁的ArrayList，写操作则通过创建底层数组的新副本来实现。...
Java源码解析CopyOnWriteArrayList的讲解
08-26
在本文中，我们将深入探讨CopyOnWriteArrayList的实现机制、成员变量、主要方法，并分析其在多线程环境下的应用场景。 成员变量 CopyOnWriteArrayList中只有两个成员变量，一个是基本数据结构array，用于保存数据...
JUC集合类 CopyOnWriteArrayList源码解析 JDK8
anlian523的博客
06-27 931
volatile + return操作/赋值操作，保证了数组成员的可见性和原子性。 读操作不用加锁，直接获取数组成员。 写操作需要加锁，并拷贝原数组成员。 优点： 保留了读操作的高性能。 避免了并发修改抛出的异常。 缺点： 写操作太多时，将产生高内存消耗。因为需要拷贝出新数组。 读操作不能保证看到最新的数据，即使写操作已经开始执行了。因为直到写操作执行setArray之前，读操作都无法看到最新数据。 场景： 读操作多，写操作少的场景。 读操作允许看到非最新数据的场景。
Java并发编程实战-CopyOnWriteArrayList源码分析
Mr_zhao
05-31 402
参考：https://www.cnblogs.com/huangjuncong/p/9160713.html https://www.iteye.com/blog/caoyaojun1988-163-com-1754686 Java.util.concurrent包中只有CopyOnWriteArrayList一种并发LIst，且这是一个线程安全的ArrayList，对齐进行修改操作和元素迭代...
Java并发编程（十八）Java 并发包中并发List源码剖析
逆流者的博客
02-02 1241
介绍 并发包中的并发List只有CopyOnWriteArrayList。CopyOnWriteArrayList是一个线程安全的ArrayList，对其进行的修改操作都是在底层的一个复制的数组（快照）上进行的，也就是使用了写时复制策略。类图结构如图： 在 CopyOnWriteArrayList 的类图中，每个CopyOnWriteArrayList对象里面有一个 array数组对象用来存放具体元素，ReentrantLock独占锁对象用来保证同时只有一个线程对 array 进行修改。这里只要记得 Re
并发编程6：CopyOnWriteArrayList 的写时复制
热门推荐
张拭心的博客 shixinzhang
08-20 1万+
首先提个问题： - 线程安全的 List 集合有什么？ - CopyOnWriteArrayList 的特点以及使用场景？ 如果这个问题你答不上来，那这篇文章可能就对你有些价值。 读完本文你将了解：CopyOnWriteArrayList 简介 CopyOnWriteArrayList 源码分析Android SDK 25 底部实现 读取操作 修改操作 迭代器 CopyOnW
Java并发编程—写时复制容器
weixin_47184173的博客
03-27 233
面试官问什么是COW "靠？我来面试你怎么骂人呢？"。 面试官："不，不是那个靠。是英文COW。" "......母牛？"。 面试官汗颜......"你知道写时复制容器么？" 通过这个小例子（非真实存在），加深一下各位对这个简称的印象。 Copy-On-Write简称COW。通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。这样做的好处是我们可以对CopyOnW
ArrayList源码解读之remove(Object o)和remve(int index)
u014344668的专栏
03-27 481
ArrayList源码解读之remove(Object o)和remve(int index) 样例 /** * 2.测试remove和fastRemove区别 * E remove(int index) */ public static void test2(){ ArrayList list1 = new ArrayList(); ...
CopyOnWriteArrayList类set方法疑惑？
要懂得舍得
12-18 396
在淘宝内网有位同事提了一个很好的问题，大家能否帮忙解答下？ 在CopyOnWriteArrayList类的set方法中有一段setArray(elements)代码，实际上这段代码并未对elements做任何改动，实现的volatile语意并不对CopyOnWriteArrayList实例产生任何影响，为什么还是要保留这行语句？见以下代码红体部分： 01
基于大模型技术的算力产业监测服务平台设计
09-17
内容概要：本文提出了一种新型算力产业监测服务平台的设计理念，运用国内自主研发的大模型技术支持，通过对传统技术的改进和完善，提出了三层架构的设计方法，即基础设施层（含向量数据库和模型训练）、大模型应用框架层（强化数据处理与多维关系挖掘）及业务层（如智能分析助手）。这种设计方案旨在提高算力产业发展监测与决策制定的质量。 适合人群：电信行业的从业人员及研究人员；算力产业链各环节管理者；政府相关机构和政策决策者。 使用场景及目标：在多种算力相关的应用场景（如云计算中心管理，数据中心监测，政策分析）中辅助决策者进行快速有效的信息获取和技术选择；助力算力产业发展方向的精确把控和战略调整。 其他说明：随着大模型技术的日臻成熟，该算力产业监测服务平台预计将进一步丰富自身的应用领域和服务深度，以促进算力行业更智慧化发展。
This_honeypot_supports_Telnet_and_SSH_two_protocol_FF-Pot.zip
最新发布
09-17
This_honeypot_supports_Telnet_and_SSH_two_protocol_FF-Pot
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值