看图学源码之 CopyOnWriteArrayList 源码分析

2023-12-08 10:36
文章标签 分析 源码 copyonwritearraylist 看图学

本文主要是介绍看图学源码之 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();}
}

这篇关于看图学源码之 CopyOnWriteArrayList 源码分析的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/469539。

相关文章

怎样通过分析GC日志来定位Java进程的内存问题

怎样通过分析GC日志来定位Java进程的内存问题

《怎样通过分析GC日志来定位Java进程的内存问题》：本文主要介绍怎样通过分析GC日志来定位Java进程的内存问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、GC 日志基础配置1. 启用详细 GC 日志2. 不同收集器的日志格式二、关键指标与分析维度1.
阅读更多...
MySQL中的表连接原理分析

MySQL中的表连接原理分析

《MySQL中的表连接原理分析》：本文主要介绍MySQL中的表连接原理分析,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录1、背景2、环境3、表连接原理【1】驱动表和被驱动表【2】内连接【3】外连接【4编程】嵌套循环连接【5】join buffer4、总结1、背景
阅读更多...
python中Hash使用场景分析

python中Hash使用场景分析

《python中Hash使用场景分析》Python的hash()函数用于获取对象哈希值,常用于字典和集合,不可变类型可哈希,可变类型不可,常见算法包括除法、乘法、平方取中和随机数哈希,各有优缺点,需根... 目录python中的 Hash除法哈希算法乘法哈希算法平方取中法随机数哈希算法小结在Python中，
阅读更多...
Java Stream的distinct去重原理分析

Java Stream的distinct去重原理分析

《JavaStream的distinct去重原理分析》Javastream中的distinct方法用于去除流中的重复元素,它返回一个包含过滤后唯一元素的新流,该方法会根据元素的hashcode和eq... 目录一、distinct 的基础用法与核心特性二、distinct 的底层实现原理1. 顺序流中的去重
阅读更多...
关于MyISAM和InnoDB对比分析

关于MyISAM和InnoDB对比分析

《关于MyISAM和InnoDB对比分析》：本文主要介绍关于MyISAM和InnoDB对比分析,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录开篇：从交通规则看存储引擎选择理解存储引擎的基本概念技术原理对比1. 事务支持：ACID的守护者2. 锁机制：并发控制的艺
阅读更多...
MyBatis Plus 中 update_time 字段自动填充失效的原因分析及解决方案(最新整理)

MyBatis Plus 中 update_time 字段自动填充失效的原因分析及解决方案(最新整理)

《MyBatisPlus中update_time字段自动填充失效的原因分析及解决方案(最新整理)》在使用MyBatisPlus时,通常我们会在数据库表中设置create_time和update... 目录前言一、问题现象二、原因分析三、总结：常见原因与解决方法对照表四、推荐写法前言在使用 MyBATis
阅读更多...
Python主动抛出异常的各种用法和场景分析

Python主动抛出异常的各种用法和场景分析

《Python主动抛出异常的各种用法和场景分析》在Python中,我们不仅可以捕获和处理异常,还可以主动抛出异常,也就是以类的方式自定义错误的类型和提示信息,这在编程中非常有用,下面我将详细解释主动抛... 目录一、为什么要主动抛出异常？二、基本语法：raise关键字基本示例三、raise的多种用法1. 抛
阅读更多...
github打不开的问题分析及解决

github打不开的问题分析及解决

《github打不开的问题分析及解决》：本文主要介绍github打不开的问题分析及解决,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、找到github.com域名解析的ip地址二、找到github.global.ssl.fastly.net网址解析的ip地址三
阅读更多...
Mysql的主从同步/复制的原理分析

Mysql的主从同步/复制的原理分析

《Mysql的主从同步/复制的原理分析》：本文主要介绍Mysql的主从同步/复制的原理分析,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录为什么要主从同步？mysql主从同步架构有哪些？Mysql主从复制的原理/整体流程级联复制架构为什么好？Mysql主从复制注意
阅读更多...
java -jar命令运行 jar包时运行外部依赖jar包的场景分析

java -jar命令运行 jar包时运行外部依赖jar包的场景分析

《java-jar命令运行jar包时运行外部依赖jar包的场景分析》：本文主要介绍java-jar命令运行jar包时运行外部依赖jar包的场景分析,本文给大家介绍的非常详细,对大家的学习或工作... 目录Java -jar命令运行 jar包时如何运行外部依赖jar包场景：解决：方法一、启动参数添加： -Xb
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2