# 前言
> **🍊作者简介：** 不肯过江东丶，一个来自二线城市的程序员，致力于用“猥琐”办法解决繁琐问题，让复杂的问题变得通俗易懂。
> **🍊支持作者：** 点赞👍、关注💖、留言💌~

我们在之前的博客中讲到了可以使用 CopyOnWriteArrayList 来代替 ArrayList 应对多线程高并发的场景，那么今天咱们就深入了解一下 CopyOnWriteArrayList 的原理🧐

# CopyOnWriteArrayList 
开始聊 CopyOnWriteArrayList 原理之前，我们先来看看什么是 CopyOnWriteArrayList 👇

> CopyOnWriteArrayList 是 Java 并发包里提供的并发类，简单来说它就是一个线程安全且读操作无锁的 ArrayList。正如其名字一样，在写操作时会复制一份新的 List，在新的 List 上完成写操作，然后再将原引用指向新的 List。这样就保证了写操作的线程安全。这是一种读写分离的并发策略。类似的还有 CopyOnWriteArraySet。

说白了 CopyOnWriteArrayList 就是线程安全版本的 ArrayList ，那么下面我们就通过源码来看看 CopyOnWriteArrayList 是如何实现的线程安全 👇

```java
public class CopyOnWriteArrayList<E>
 implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
 private static final long serialVersionUID = 8673264195747942595L;

 /** The lock protecting all mutators */
 final transient ReentrantLock lock = new ReentrantLock();

 /** The array, accessed only via getArray/setArray. */
 private transient volatile Object[] array;

 /**
 * Gets the array. Non-private so as to also be accessible
 * from CopyOnWriteArraySet class.
 */
 final Object[] getArray() {
 return array;
 }

 /**
 * Sets the array.
 */
 final void setArray(Object[] a) {
 array = a;
 }

 /**
 * Creates an empty list.
 */
 public CopyOnWriteArrayList() {
 setArray(new Object[0]);
 }

 /**
 * Creates a list containing the elements of the specified
 * collection, in the order they are returned by the collection's
 * iterator.
 *
 * @param c the collection of initially held elements
 * @throws NullPointerException if the specified collection is null
 */
 public CopyOnWriteArrayList(Collection<? extends E> c) {
 Object[] elements;
 if (c.getClass() == CopyOnWriteArrayList.class)
 elements = ((CopyOnWriteArrayList<?>)c).getArray();
 else {
 elements = c.toArray();
 // c.toArray might (incorrectly) not return Object[] (see 6260652)
 if (elements.getClass() != Object[].class)
 elements = Arrays.copyOf(elements, elements.length, Object[].class);
 }
 setArray(elements);
 }

	//源码实在是太长了，此处略去N行源码.....😂
}
```

通过源码我们可以看到，CopyOnWriteArrayList 和 ArrayList 一样，都是在内部维护了一个数组。操作 CopyOnWriteArrayList 其实就是在操作内部的数组。接下来我们来看看 CopyOnWriteArrayList 和 ArrayList 的不同之处：

> 🍊 **不同一** 🍊 我们可以看到 CopyOnWriteArrayList 中维护的 array 数组被 volatile 关键字修饰了。volatile 关键字保证了每次拿到的内部数组都是最新值。当一个共享变量被 volatile 关键字修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值，因此哪怕别的线程刚修改完内部数组，也能保证获取内部数组时是最新的。 🍊 **不同二** 🍊 既然 CopyOnWriteArrayList 是线程安全的，那么必然离不开锁的帮助，正如源码中写的那样，CopyOnWriteArrayList 每创建一个实例，都会同时创建一个 ReentrantLock 锁，并且在增、删、改操作时添加锁。 🍊 **不同三** 🍊 使用 CopyOnWrite 的方式操作数组，可能有些小伙伴并不太理解什么是 CopyOnWrite，下面我们就详细说说~

CopyOnWrite，即每次在写入之前，先获取源数据的拷贝，修改完拷贝后，再保存到源数据中。我们还是通过源码一起学习一下 👇

🍓 **get 方法**

```java
@SuppressWarnings("unchecked")
private E get(Object[] a, int index) {
 return (E) a[index];
}

/**
 * {@inheritDoc}
 *
 * @throws IndexOutOfBoundsException {@inheritDoc}
 */
public E get(int index) {
 return get(getArray(), index);
}
```
get 方法比较容易理解，因为 CopyOnWriteArrayList 中的 get 方法和 ArrayList 中的 get 方法没什么区别，都是直接返回数组中的对象，并没有加锁的操作。

🍓 **set 方法**

```java
/**
 1. Replaces the element at the specified position in this list with the
 2. specified element.
 3. 4. @throws IndexOutOfBoundsException {@inheritDoc}
 */
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();
 }
}
```
CopyOnWriteArrayList 的 set 方法就相对复杂一些了，毕竟涉及到了加锁和释放锁的操作，我们将 set 方法的执行步骤总结一下：

 1. 加锁
 2. 获取源数组
 3. 判断新值和旧值是否相同
 4. 新、旧值不同时，则拷贝源数组，更新值，再更新源数组；新、旧值相同时，不更新值，再更新源数组（原数组内容并未发生变化）
 5. 释放锁

🍓 **add 方法**

```java
/**
 1. Appends the specified element to the end of this list.
 2. 3. @param e element to be appended to this list
 4. @return {@code true} (as specified by {@link Collection#add})
 */
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;
 setArray(newElements);
 return true;
 } finally {
 lock.unlock();
 }
}
```
CopyOnWriteArrayList 的 add 方法和 ArrayList 的 add 方法差别并不是很大了，理解起来也相对容易一些，我们将 add 方法的执行流程做一个总结：
 1. 加锁
 2. 获取源数组
 3. 复制出来一个源数组长度+1的新数组
 4. 在复制出来的新数组末尾赋值，再更新源数组
 5. 释放锁

🍓 **remove 方法**

```java
/**
 1. Removes the element at the specified position in this list.
 2. Shifts any subsequent elements to the left (subtracts one from their
 3. indices). Returns the element that was removed from the list.
 4. 5. @throws IndexOutOfBoundsException {@inheritDoc}
 */
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)
 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);
 setArray(newElements);
 }
 return oldValue;
 } finally {
 lock.unlock();
 }
}
```
老规矩，我们还是对方法的执行流程做一个总结：
 1. 加锁
 2. 获取源数组
 3. 判断删除的位置是不是数组末尾
 4. 是末尾的话，复制出一个源数组长度减一的新数组，然后更新源数组；不是末尾的话，做成一个不包含需要删除的元素的新数组，然后更新源数组
 6. 释放锁

通过增、删、改、查的源码，我们可以对上面提到的“不同点二”中的“**在增、删、改操作时添加锁**”加以佐证。看到这里，可能有些小伙伴就会产生疑问了，既然 CopyOnWriteArrayList 中的增、删、改操作都会加锁，那么为什么还要复制出一个新数组去操作呢？

> 其实在我第一次看到 CopyOnWriteArrayList 的源码时就提出了相同的问题，为什么还要复制一个新数组呢？其实各位小伙伴开动一下聪明的小脑瓜应该可以猜得到~ 为了提升效率，CopyOnWriteArrayList 的 get 方法中并未加锁，那么这就意味着，读操作可以在执行增、删、改操作中的任何一步读取数组里的值。因此为了保证数据的最终一致性，就需要复制出来一个新的数组，对新数组更新完毕后再刷新源数组，这样才能保证读操作取到的要么是旧值，要么是最新值。

通过上面的讲解，相信各位小伙伴对 CopyOnWriteArrayList 的原理都有了一定的理解，下面我们再对 CopyOnWriteArrayList 做一个总结👇

> 因为 CopyOnWriteArrayList 具有线程安全的特性，我们可以高并发场景中放心的使用，在保证线程安全的情况下，可以获得非常高效的读操作。但是每次写操作都需要复制一份新数组，所以写操作的执行效率就相对低一些了。因此，当实际场景中的数组长度很长时，不建议使用CopyOnWriteArrayList。

# 小结
本人经验有限，有些地方可能讲的没有特别到位，如果您在阅读的时候想到了什么问题，欢迎在评论区留言，我们后续再一一探讨🙇‍

> 希望各位小伙伴动动自己可爱的小手，来一波点赞+关注 (✿◡‿◡) 让更多小伙伴看到这篇文章~ 蟹蟹呦(●'◡'●)

如果文章中有错误，欢迎大家留言指正；若您有更好、更独到的理解，欢迎您在留言区留下您的宝贵想法。

> *你在被打击时，记起你的珍贵，抵抗恶意；*
*你在迷茫时，坚信你的珍贵，抛开蜚语；*
**爱你所爱 行你所行 听从你心 无问东西**

🍊作者简介： 不肯过江东丶，一个来自二线城市的程序员，致力于用“猥琐”办法解决繁琐问题，让复杂的问题变得通俗易懂。 🍊支持作者： 点赞👍、关注💖、留言💌~

大聪明教你学Java | 深入浅出聊 CopyOnWriteArrayList 原理

我们都知道可以使用 CopyOnWriteArrayList 来代替 ArrayList 应对多线程高并发的场景，那么今天咱们就深入了解一下 CopyOnWriteArrayList 的原理🧐

高级Java开发工程师

编程语言

后端

CopyOnWriteArrayList是Java并发包中的线程安全List实现，采用读写分离策略。写操作时复制新数组完成修改，保证读操作无锁高效。源码分析显示其通过volatile数组和ReentrantLock确保线程安全，适合读多写少场景。但频繁写操作会导致性能下降，大数组场景慎用。

Java

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

大聪明教你学Java | 深入浅出聊 CopyOnWriteArrayList 原理-腾讯云开发者社区-腾讯云

大聪明教你学Java | 深入浅出聊 CopyOnWriteArrayList 原理

大聪明教你学Java | 深入浅出聊 CopyOnWriteArrayList 原理

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐