看图学源码之 CopyOnWriteArrayList 源码分析

基本简介：

是Java中的一个线程安全的List实现，也是ArrayList 的安全版本，所以就不会有ArrayList 的并发修改异常 的问题产生了

原理

每次在对 List 进行修改时，创建一个新的副本（即拷贝），而不是直接在原始列表上进行修改。

在创建新的副本时，CopyOnWriteArrayList会复制整个内部数组，并在副本上进行修改操作。所以读操作是不会被阻塞的，因为读取操作可以同时在原始列表和新创建的副本上进行。

由于每次修改都会创建一个新的副本，所以CopyOnWriteArrayList适用于读取操作频繁、写入操作较少的场景。它是可以避免读与写之间的竞争条件，从而提供了较好的并发性能。

虽然CopyOnWriteArrayList提供了线程安全的读取操作，但写入操作的性能相对较低，因为每次写入操作都需要复制整个内部数组。因此，如果需要频繁进行写入操作或对 List 的实时性要求较高，可能不适合使用CopyOnWriteArrayList。

总的来说就是：CopyOnWriteArrayList的原理是通过创建副本来实现线程安全的读取操作，避免了读写竞争条件，但写入操作的性能相对较低。

弊端

1、 每次都要赋值，浪费很大的内存空间

2、读线程可能读不到正在写入的数据，是无法保持 数据的实时一致，只能保证数据的最终一致性。

源码解释

public class CopyOnWriteArrayList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
// 此处是和ArrayList一样的
}

使用的锁

final transient ReentrantLock lock = new ReentrantLock();

装载数组

private transient volatile Object[] array;final Object[] getArray() {return array;
}final void setArray(Object[] a) {array = a;
}

构造器

// 无参构造器
public CopyOnWriteArrayList() {setArray(new Object[0]);
}// 有参构造器
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));
}

读

get
get(int index)

返回此列表中指定位置的元素。

//返回此列表中指定位置的元素。
public E get(int index) {return get(getArray(), index);
}
//获取数组
final Object[] getArray() {return array;
}
get(Object[] a, int index)

返回此列表中指定位置的元素。

private transient volatile Object[] array;private E get(Object[] a, int index) {return (E) a[index];
}
contains
contains(Object o)

如果此列表包含指定元素，则返回true 。更正式地说，当且仅当此列表包含至少一个元素e且满足(o==null ? e==null : o.equals(e))时，才返回true

在这里插入图片描述

public boolean contains(Object o) {Object[] elements = getArray();// 遍历集合找到返回true 否则返回falsereturn indexOf(o, elements, 0, elements.length) >= 0;
}
containsAll(Collection<?> c)

如果此列表包含指定集合的所有元素，则返回true

在这里插入图片描述

public boolean containsAll(Collection<?> c) {Object[] elements = getArray();int len = elements.length;// 遍历指定集合，在挨个遍历原数组中的元素进行匹配，找不到就返回不存在，falsefor (Object e : c) {if (indexOf(e, elements, 0, len) < 0)return false;}// 否则返回truereturn true;
}

写

set
set(int index, E element)

将此列表中指定位置的元素替换为指定元素。

在这里插入图片描述

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;// 对原来的数组进行copy，并设置新数组的容量 就是 原数组的容量 Object[] newElements = Arrays.copyOf(elements, len);// 修改新数组指定位置的元素newElements[index] = element;// 新数组 变为 下次getArray 的数组setArray(newElements);} else {// 修改的值和原来的一样，不用修改setArray(elements);}// 返回旧的值return oldValue;} finally {lock.unlock();}
}
add
add(E e)

此方法会添加原数组就有的重复的元素

将指定元素追加到此列表的末尾。

在这里插入图片描述

public boolean add(E e) {final ReentrantLock lock = this.lock;lock.lock();try {// 获取当前数组Object[] elements = getArray();// 当前数组的长度int len = elements.length;// copy 原数组的值到新数组中，并设置新数组的容量是 原数组的容量 + 1 Object[] newElements = Arrays.copyOf(elements, len + 1);// 在新数组的最后位置添加这个元素newElements[len] = e;// 新数组 变为 下次getArray 的数组setArray(newElements);return true;} finally {lock.unlock();}}
add(int index, E element)

此方法会添加原数组就有的重复的元素

在此列表中的指定位置插入指定元素。将当前位于该位置的元素（如果有）和任何后续元素向右移动（将其索引加一）

在这里插入图片描述

public void add(int index, E element) {final ReentrantLock lock = this.lock;lock.lock();try {Object[] elements = getArray();int len = elements.length;if (index > len || index < 0)throw new IndexOutOfBoundsException("Index: "+index+", Size: "+len);Object[] newElements;// 需要移动的元素的个数int numMoved = len - index;// 在末尾添加if (numMoved == 0)//copy 原数组的值到新数组中，并设置新数组的容量是 原数组的容量 + 1 newElements = Arrays.copyOf(elements, len + 1);// else {//设置新数组的容量是 原数组的容量 + 1 newElements = new Object[len + 1];// copy 原数组中 指定位置前 和指定位置 后的值到新数组中System.arraycopy(elements, 0, newElements, 0, index);System.arraycopy(elements, index, newElements, index + 1,numMoved);}// 指定位置填充元素newElements[index] = element;// 新数组 变为 下次getArray 的数组setArray(newElements);} finally {lock.unlock();}
}
addAll(Collection<? extends E> c)

此方法会添加原数组就有的重复的元素

将指定集合中的所有元素按照指定集合的迭代器返回的顺序附加到此列表的末尾。

在这里插入图片描述

public boolean addAll(Collection<? extends E> c) {// 转为数组Object[] cs = (c.getClass() == CopyOnWriteArrayList.class) ?((CopyOnWriteArrayList<?>)c).getArray() : c.toArray();if (cs.length == 0)return false;final ReentrantLock lock = this.lock;lock.lock();try {Object[] elements = getArray();int len = elements.length;// 要是原数组长度为 0 并且 添加的集合 是  CopyOnWriteArrayList 或者  ArrayListif (len == 0 && (c.getClass() == CopyOnWriteArrayList.class || c.getClass() == ArrayList.class)) {// 新增的集合就指定为 下次getArray 的数组 setArray(cs);} else {// copy 原数组的值到新数组中，并设置新数组的容量是 原数组的容量 + 新增集合的长度Object[] newElements = Arrays.copyOf(elements, len + cs.length);// 将集合c 元素 copy 到末尾System.arraycopy(cs, 0, newElements, len, cs.length);// 新数组 变为 下次getArray 的数组setArray(newElements);}return true;} finally {lock.unlock();}
}
addAll(int index, Collection<? extends E> c)

此方法会添加原数组就有的重复的元素

将指定集合中的所有元素插入到此列表中，从指定位置开始。将当前位于该位置的元素（如果有）和任何后续元素向右移动（增加它们的索引）

在这里插入图片描述

public boolean addAll(int index, Collection<? extends E> c) {Object[] cs = c.toArray();final ReentrantLock lock = this.lock;lock.lock();try {Object[] elements = getArray();int len = elements.length;if (index > len || index < 0)throw new IndexOutOfBoundsException("Index: "+index+", Size: "+len);if (cs.length == 0)return false;int numMoved = len - index;Object[] newElements;// 不移动，直接copy 到原来数组的末尾if (numMoved == 0)newElements = Arrays.copyOf(elements, len + cs.length);else {// 指定位置之前和之后的元素拷贝到 新的副本中newElements = new Object[len + cs.length];System.arraycopy(elements, 0, newElements, 0, index);System.arraycopy(elements, index,newElements, index + cs.length,numMoved);}// 在指定位置之后 填充集合元素System.arraycopy(cs, 0, newElements, index, cs.length);// // 新数组 变为 下次getArray 的数组setArray(newElements);return true;} finally {lock.unlock();}
}
addAllAbsent(Collection<? extends E> c)

此方法不会添加原数组就有的重复的元素

将指定集合中尚未包含在此列表中的所有元素按照指定集合的迭代器返回的顺序追加到此列表的末尾。

在这里插入图片描述

public int addAllAbsent(Collection<? extends E> c) {Object[] cs = c.toArray();// 创建一个cs的副本，以防止对原始对象的修改影响到cs变量。if (c.getClass() != ArrayList.class) {cs = cs.clone();}if (cs.length == 0)return 0;final ReentrantLock lock = this.lock;lock.lock();try {Object[] elements = getArray();int len = elements.length;int added = 0;  // 不重复元素的个数// uniquify and compact elements in csfor (int i = 0; i < cs.length; ++i) {Object e = cs[i];// 原数组中 和 转为数组的集合中都没有这个元素							if (indexOf(e, elements, 0, len) < 0 &&indexOf(e, cs, 0, added) < 0)//将不重复的元素添加到 cs 数组中。cs[added++] = e;}if (added > 0) {Object[] newElements = Arrays.copyOf(elements, len + added);//不重复元素放到新元素的末尾System.arraycopy(cs, 0, newElements, len, added);setArray(newElements);}// 返回原数组中不存在的集合中的元素的个数return added;} finally {lock.unlock();}
}
// 返回此列表中指定元素第一次出现的索引，如果此列表不包含该元素，则返回 -1。
// 更正式地说，返回满足(o==null ? get(i)==null : o.equals(get(i))) 的最低索引i(第一个位置) ，如果没有这样的索引，则返回 -1 。// 遍历数组找到符合的元素，找不到返回 -1private static int indexOf(Object o, Object[] elements,int index, int fence) {if (o == null) {for (int i = index; i < fence; i++)if (elements[i] == null)return i;} else {for (int i = index; i < fence; i++)if (o.equals(elements[i]))return i;}return -1;}
addIfAbsent(E e)

此方法不会添加原数组就有的重复的元素

追加该元素（如果不存在）。

在这里插入图片描述

public boolean addIfAbsent(E e) {Object[] snapshot = getArray();// 要是元素在原来的数组中是存在的直接返回，否则就调用 addIfAbsent(e, snapshot)return indexOf(e, snapshot, 0, snapshot.length) >= 0 ? false :addIfAbsent(e, snapshot);
}private boolean addIfAbsent(E e, Object[] snapshot) {final ReentrantLock lock = this.lock;lock.lock();try {Object[] current = getArray();int len = current.length;// 要是数组发生了变化，表示有其他线程正在竞争修改这个数组if (snapshot != current) {// 得到两个数组的公共长度，以小的值为准int common = Math.min(snapshot.length, len);// 遍历两个数组的公共部分for (int i = 0; i < common; i++)// 两个数组又不想等的元素  && 当前数组已经存在要添加的元素if (current[i] != snapshot[i] && eq(e, current[i]))// 不添加return false;// 遍历结束，前面的部分都是一样的// 查找当前数组剩余部分的元素 要是此时能找到添加的元素也 不添加if (indexOf(e, current, common, len) >= 0)return false;}//否则，创建当前数组的副本，并在结尾加上这个元素Object[] newElements = Arrays.copyOf(current, len + 1);newElements[len] = e;setArray(newElements);return true;} finally {lock.unlock();}}
remove
remove(int index)

删除此列表中指定位置的元素。将所有后续元素向左移动（从索引中减去 1）。返回从列表中删除的元素。

在这里插入图片描述

  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;// 不要移动  直接拷贝，长度为原来数组的长度 -1if (numMoved == 0)setArray(Arrays.copyOf(elements, len - 1));else {// 新建副本，副本的长度减少为原来数组的长度 -1// 拷贝到新数组中该位置之前 和 该元素之后 的元素// 新数组 变为 下次getArray 的数组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();}}
remove(Object o)

在这里插入图片描述

从此列表中删除第一次出现的指定元素（如果存在）。如果此列表不包含该元素，则它不会更改。更正式地说，删除具有最低索引i元素，使得(o==null ? get(i)==null : o.equals(get(i))) （如果存在这样的元素）。如果此列表包含指定的元素（或者等效地，如果此列表由于调用的结果而更改），则返回true 。

public boolean remove(Object o) {Object[] snapshot = getArray();// 判断原数组是否存在当前 元素，并返回当前元素的位置int index = indexOf(o, snapshot, 0, snapshot.length);// 存在才调用 remove(o, snapshot, index); 移除return (index < 0) ? false : remove(o, snapshot, index);
}
remove(Object o, Object[] snapshot, int index)

给定的最近快照在给定索引处包含 o。

在这里插入图片描述

 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;//上面两个数组公共位置的元素都是一样的，那么现在就是当前index位置的元素判断是不是一样的 if (current[index] == o)break findIndex; // 是就结束循环// 从index位置遍历现在数组的元素，直到结束index = indexOf(o, current, index, len);// 要是找不到，删除失败if (index < 0)return false;}// 新建副本，副本的长度减少为原来数组的长度 -1// 拷贝到新数组中该位置之前 和 该元素之后 的元素// 新数组 变为 下次getArray 的数组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();}}
removeRange(int fromIndex, int toIndex)

从此列表中删除索引介于fromIndex （包含）和toIndex （不包含）之间的所有元素。将所有后续元素向左移动（减少它们的索引）。此调用将列表缩短(toIndex - fromIndex)个元素。 （如果toIndex==fromIndex ，则此操作无效。）

在这里插入图片描述

 void removeRange(int fromIndex, int toIndex) {final ReentrantLock lock = this.lock;lock.lock();try {Object[] elements = getArray();int len = elements.length;if (fromIndex < 0 || toIndex > len || toIndex < fromIndex)throw new IndexOutOfBoundsException();// 删除指定范围之后的数组长度int newlen = len - (toIndex - fromIndex);// 需要移动的元素 int numMoved = len - toIndex;// 不用移动，直接拷贝之前的元素if (numMoved == 0)setArray(Arrays.copyOf(elements, newlen));else {// 新建副本，副本的长度减少为原来数组的长度 -1// 拷贝到新数组中该位置之前 和 该元素之后 的元素// 新数组 变为 下次getArray 的数组Object[] newElements = new Object[newlen];System.arraycopy(elements, 0, newElements, 0, fromIndex);System.arraycopy(elements, toIndex, newElements,fromIndex, numMoved);setArray(newElements);}} finally {lock.unlock();}}
removeAll(Collection<?> c)

从此列表中删除指定集合中包含的所有元素。由于需要内部临时数组，因此在此类中这是一个特别昂贵的操作。

在这里插入图片描述

   public boolean removeAll(Collection<?> c) {if (c == null) throw new NullPointerException();final ReentrantLock lock = this.lock;lock.lock();try {Object[] elements = getArray();int len = elements.length;if (len != 0) {// temp 数组保存需要保留的元素int newlen = 0;Object[] temp = new Object[len];// 遍历 原数组for (int i = 0; i < len; ++i) {Object element = elements[i];// 要是删除元素的集合不包含这个元素，塞到temp数组中if (!c.contains(element))temp[newlen++] = element;}// 有删除的元素if (newlen != len) {// 将temp copy 作为新数组中setArray(Arrays.copyOf(temp, newlen));return true;}}return false;} finally {lock.unlock();}}
removeIf(Predicate<? super E> filter)

根据指定条件过滤集合元素的功能

在这里插入图片描述

public boolean removeIf(Predicate<? super E> filter) { //Predicate<? super E> 类型的参数 filter，用于过滤集合中的元素if (filter == null) throw new NullPointerException();final ReentrantLock lock = this.lock;lock.lock();try {Object[] elements = getArray();int len = elements.length;if (len != 0) {int newlen = 0;Object[] temp = new Object[len];//遍历现在的数组，如果元素不满足 filter 的条件，则将其保存在 temp 数组中，并增加 newlen 的值。for (int i = 0; i < len; ++i) {@SuppressWarnings("unchecked") E e = (E) elements[i];if (!filter.test(e))temp[newlen++] = e;}//有元素被删除if (newlen != len) {// 将temp copy 作为新数组中setArray(Arrays.copyOf(temp, newlen));return true;}}return false;} finally {lock.unlock();}
}
clear

从此列表中删除所有元素。该调用返回后列表将为空。

public void clear() {final ReentrantLock lock = this.lock;lock.lock();try {// 设置一个空的数组作为新的数组setArray(new Object[0]);} finally {lock.unlock();}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/257262.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

web：[GXYCTF2019]BabyUpload（文件上传、一句话木马、文件过滤）

web：[GXYCTF2019]BabyUpload（文件上传、一句话木马、文件过滤）

题目 页面显示为文件上传 随便上传一个文件看看 上传一个文本文件显示 上传了一个图片显示 上传包含一句话木马的图片 上传了一个包含php一句话木马的文件&#xff0c;显示如上 换一个写法 上传成功 尝试上传.htaccess&#xff0c;上传失败&#xff0c;用抓包修改文件后缀 …
阅读更多...
Open-Falcon(一)环境配置

Open-Falcon(一)环境配置

目录 ip划分一、主机准备二、环境配置2.1修改主机名、修改hosts文件2.2配置阿里源&#xff0c;安装工具2.3关闭防火墙、selinux2.4配置时间2.5安装go2.6安装redis2.7 安装mysql初始化MySQL表结构 ip划分 主机名IP服务open-faclon-server192.168.150.200open-faclon-serverngin…
阅读更多...
【Python】Faker库详解：创建测试数据轻而易举

【Python】Faker库详解：创建测试数据轻而易举

Python Faker库详解&#xff1a;创建测试数据轻而易举 在软件开发和测试过程中&#xff0c;通常需要大量的测试数据来模拟真实环境。Python的Faker库为开发者提供了一个方便、灵活且强大的工具&#xff0c;用于生成各种虚构数据。本文将深入介绍Faker库&#xff0c;演示其基本…
阅读更多...
基于ssm人事管理信息系统论文

基于ssm人事管理信息系统论文

摘 要 现代经济快节奏发展以及不断完善升级的信息化技术&#xff0c;让传统数据信息的管理升级为软件存储&#xff0c;归纳&#xff0c;集中处理数据信息的管理方式。本人事管理信息系统就是在这样的大环境下诞生&#xff0c;其可以帮助管理者在短时间内处理完毕庞大的数据信息…
阅读更多...
优化系统性能：深入性能测试的重要性与最佳实践

优化系统性能：深入性能测试的重要性与最佳实践

目录 引言 1. 为什么性能测试重要&#xff1f; 1.1 用户体验 1.2 系统稳定性 1.3 成本节约 1.4 品牌声誉 2. 性能测试的关键步骤 2.1 制定性能测试计划 2.2 确定性能测试类型 2.3 设计性能测试用例 2.4 配置性能测试环境 2.5 执行性能测试 2.6 分析和优化 2.7 回…
阅读更多...
编程实战：自己编写HTTP服务器（系列3：处理框架）

编程实战：自己编写HTTP服务器（系列3：处理框架）

系列入口&#xff1a;编程实战&#xff1a;自己编写HTTP服务器&#xff08;系列1&#xff1a;概述和应答&#xff09;-CSDN博客 本文介绍处理框架。 一、框架概述 处理框架针对的是一个连接&#xff0c;里面用了循环&#xff0c;支持HTTP1.1&#xff0c;如果不循环就是1.0了&am…
阅读更多...
Spring 依赖注入的三种方式优缺点

Spring 依赖注入的三种方式优缺点

小王学习录 前言属性注入1. 属性注入的优点2. 属性注入的缺点 Setter注入Setter注入的优点Setter注入的缺点 构造方法注入1. 构造方法的优点 总结补充Aurowired注解和Resource注解的区别 前言 在前面的文章中介绍了基于注解的方式将Bean存储到Spring中, 接下来介绍如何基于注解…
阅读更多...
什么是https加密协议，相比http的好处在哪？

什么是https加密协议，相比http的好处在哪？

先了解什么是http HTTP&#xff08;Hypertext Transfer Protocol&#xff09;是一种用于在计算机网络上传输超文本的应用层协议。它是一种无状态的、无连接的协议&#xff0c;通常用于在Web浏览器和服务器之间传输HTML页面、图片、音频、视频以及其他数据资源。 以下是HTTP的…
阅读更多...
光伏项目开发的步骤

光伏项目开发的步骤

光伏项目开发是一种将太阳能转化为电能的过程&#xff0c;它涉及到多个步骤和因素。下面将详细介绍光伏项目开发的步骤。 一、项目选址 选择合适的场地是光伏项目开发的第一步。选址时要考虑太阳辐射强度、地理位置、地形和气候等因素。通常来说&#xff0c;阳光充足、遮挡物少…
阅读更多...
docker镜像仓库hub.docker.com无法访问

docker镜像仓库hub.docker.com无法访问

docker镜像仓库hub.docker.com无法访问 文章主要内容&#xff1a; 介绍dockerhub为什么无法访问解决办法 1 介绍dockerhub为什么无法访问 最近许多群友都询问为什么无法访问Docker镜像仓库&#xff0c;于是我也尝试去访问&#xff0c;结果果然无法访问。 大家的第一反应就是…
阅读更多...
Python-滑雪大冒险【附源码】

Python-滑雪大冒险【附源码】

滑雪大冒险 《滑雪大冒险》是一款充满趣味性和挑战性的休闲竞技游戏&#xff0c;在游戏中&#xff0c;玩家将扮演一位勇敢的滑雪者&#xff0c;在雪山上展示他们的滑雪技巧&#xff0c;游戏采用2D图形界面&#xff0c;以第三人称视角呈现 运行效果&#xff1a;用方向键及方向键…
阅读更多...
Javaweb之Maven仓库的详细解析

Javaweb之Maven仓库的详细解析

2.3 Maven仓库 仓库&#xff1a;用于存储资源&#xff0c;管理各种jar包 仓库的本质就是一个目录(文件夹)&#xff0c;这个目录被用来存储开发中所有依赖(就是jar包)和插件 Maven仓库分为&#xff1a; 本地仓库&#xff1a;自己计算机上的一个目录(用来存储jar包) 中央仓库&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023