CopyOnWriteArrayList 的故事-一起看看java原生的读写分离

礼华發表於 2025-10-11 10:40:00

CopyOnWriteArrayList 的故事--一起看看java原生的读写分离

CopyOnWriteArrayList 是JUC中，为了实现高并发而提供的list容器之一。 对于大部分的业务场景，都是读多写少，并发度也基本卡在了读的位置。 通常支持并发的容器在解决并发时，采用是： （1）数据分割，每个线程只操作属于当前线程自己的数据，如ThreadLocal （感兴趣的同学可以看我前文《Java内存模型及Java关键字 volatile的作用和使用说明》  https://www.cnblogs.com/jilodream/p/9452391.html） （2）元数据被操作时，通过锁来进行并发控制。（如Hashtable 、concurrentHashMap 等） 今天要说的CopyOnWriteArrayList的思想是读写分离： 如图，他的思路大概是这样的，
<img src="https://img2024.cnblogs.com/blog/704073/202510/704073-20251011104422750-307323429.png" alt="cowlist" loading="lazy">
 
（0）提供一个数组来作为队列：
（1）所有的读操作直接读取数组，由于只有读操作，因此不会存在数据安全问题。 （2）所有的写操作是会将原始数据（数组）+改动操作（增删数据）直接体现到另外一个新的数组中。(防盗连接：本文首发自http://www.cnblogs.com/jilodream/ )在写操作完毕之前，替换为原有的，外部读可以访问的数组。 （3）由于写操作才会有并发的问题，因此所有的写操作是通过锁来隔离的。而读操作都是建立在一个完整的，不被改动的数组中的，因此读也就不再需要锁了。
先来看下命名 Copy复制/拷贝 On在...时间点 Write 写 Array数组 List队列 结合起来就是一个在写数据时进行拷贝的数组队列。一语道破该并发容器的核心。 怎么使用CopyOnWriteArrayList就不说了，他的常规使用与其他List并没有太大的区别。 我们直接来看源码（我这里采用的是JDK17）： 首先来看定义
<div class="cnblogs_code">
<pre>public class CopyOnWriteArrayList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable</pre>
</div>
定义中首先指定该容器依次实现了 List<E>, ---> 队列接口 RandomAccess, ---> 标记接口，支持随机访问 Cloneable, ---> 标记访问，支持拷贝 java.io.Serializable --->标记接口，支持可序列化 至于什么是标记接口，可以看我的这篇文章（为什么这些java接口没有抽象方法？浅谈Java标记接口  https://www.cnblogs.com/jilodream/p/5986519.html）。 （ps. 不知道大家发现没有代表能力的接口jdk往往喜欢加-able，表示可以的。这在代码简洁之道这本书中也是推荐的命名方式之一。）
我们接下来看下它的核心源码。 首先是元数据部分：
<div class="cnblogs_code">
<pre> /**
* The lock protecting all mutators.(We have a mild preference
* for builtin monitors over ReentrantLock when either will do.)
*/
final transient Object lock = new Object();

/** The array, accessed only via getArray/setArray. */
private transient volatile Object[] array;</pre>
</div>
定义了一个Object lock作为全局锁。用final transient 来修饰。 final 是为了防止锁被乱改，导致出现安全问题。 transient 则是表示在自动序列化时，不要主动来序列化该字段。这里也是了为了数据安全考虑的，防止正反序列化后，实例中的lock对象暴露出去，导致有安全问题。 注意在JDK1.8中，锁的实现使用的是ReentrantLock。但是在后续的版本中由于synchronized锁的优化，又使用了syncronized锁。源码中的注释也有这样写：
<div class="cnblogs_code">
<pre> /**
* The lock protecting all mutators.(We have a mild preference
* for builtin monitors over ReentrantLock when either will do.)
*/
当内置锁和 ReentrantLock 都能用的时候，我们略微倾向于使用内置锁。</pre>
</div>
定义了用来存放Object[] array;使用了transient volatile来修饰。 使用transient是为了解决序列化的问题。这里就会有一个疑问，为什么支持序列化，(防盗连接：本文首发自http://www.cnblogs.com/jilodream/ )并且又要在array 前边修饰transient，防止它序列化？这是为何，我们序列化不就是为了转存数据么？ 使用volatile修饰是为了保证array 发生变化时，所有直接使用的线程可以及时的感知到。这里需要对volatile有一定的认知才能明白，不太明白的同学请先了解 首先是构造方法：
<div class="cnblogs_code">
<pre> public CopyOnWriteArrayList() {
 setArray(new Object);
}</pre>
</div>
注意看CopyOnWriteArrayList是将一个len=0的数组初始化到容器中的。而并不像ArrayList一样预留一个初始化大小的数组。这是为什么呢？
然后是核心的读方法：
<div class="cnblogs_code">
<pre> public E get(int index) {
 return elementAt(getArray(), index);
}

 static <E> E elementAt(Object[] a, int index) {
 return (E) a;
}</pre>
</div>
很简单，从指定的数组中直接读出对应位置的元素，返回
核心的四个写方法：
（1）队列添加全新元素
<div class="cnblogs_code">
<pre> public boolean add(E e) {
 synchronized (lock) {
 Object[] es = getArray();
 int len = es.length;
 es = Arrays.copyOf(es, len + 1);
 es = e;
 setArray(es);
 return true;
 }
}</pre>
</div>
1、写方法直接加了一把全局锁。 2、然后在同步的代码块中，将元数据加入到一个（比当前数组长度+1长度的）新数组中。 3、接着将新元素添加到队列的末尾中。 4、最后将新数组覆盖到原数组中。 5、由于原数组在定义时，使用了volatile关键字修饰。因此下次的读操作就会立刻感知到该元素，
（2）队列指定位置添加全新元素
<div class="cnblogs_code">
<pre> public void add(int index, E element) {
 synchronized (lock) {
 Object[] es = getArray();
 int len = es.length;
 if (index > len || index < 0)
 throw new IndexOutOfBoundsException(outOfBounds(index, len));
 Object[] newElements;
 int numMoved = len - index;
 if (numMoved == 0)
 newElements = Arrays.copyOf(es, len + 1);
 else {
 newElements = new Object;
 System.arraycopy(es, 0, newElements, 0, index);
 System.arraycopy(es, index, newElements, index + 1,
 numMoved);
 }
 newElements = element;
 setArray(newElements);
 }
}</pre>
</div>
1、写方法直接加了一把全局锁。 2、然后判断当前添加位置的索引是否合法超出了len的合理范围，如果是，那么就抛出异常。 3、然后判断当前添加位置是不是数组的最后位置： <1>如果是的话，就把原数组的所有元素拷贝到新数组的中。新数组的长度等于老数组+1。 <2>如果不是的话，就直接new 一个长度为len+1的数组。然后分别把老数组的前后两部分拷贝到新数组中。 4、将添加位置的元素设置为新元素。 （3）移出指定位置的元素
<div class="cnblogs_code">
<pre> public E remove(int index) {
 synchronized (lock) {
 Object[] es = getArray();
 int len = es.length;
 E oldValue = elementAt(es, index);
 int numMoved = len - index - 1;
 Object[] newElements;
 if (numMoved == 0)
 newElements = Arrays.copyOf(es, len - 1);
 else {
 newElements = new Object;
 System.arraycopy(es, 0, newElements, 0, index);
 System.arraycopy(es, index + 1, newElements, index,
 numMoved);
 }
 setArray(newElements);
 return oldValue;
 }
}</pre>
</div>
1、移出方法首先加入一把全局锁 2、获取指定位置的元素 3、判断移出元素是不是队列的末尾： 如果是的话，(防盗连接：本文首发自http://www.cnblogs.com/jilodream/ )就把原数组的去除末尾元素的部分拷贝到新数组的中。新数组的长度等于老数组-1。 如果不是的话，就直接new 一个长度为len-1的数组。然后分别把老数组的前后两部分拷贝到新数组中。 4、返回查询到的指定元素
（4）移出指定元素
<div class="cnblogs_code">
<pre> public boolean remove(Object o) {
 Object[] snapshot = getArray();
 int index = indexOfRange(o, snapshot, 0, snapshot.length);
 return index >= 0 && remove(o, snapshot, index);
}

private boolean remove(Object o, Object[] snapshot, int index) {
 synchronized (lock) {
 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 != snapshot
 && Objects.equals(o, current)) {
 index = i;
 break findIndex;
 }
 }
 if (index >= len)
 return false;
 if (current == o)
 break findIndex;
 index = indexOfRange(o, current, index, len);
 if (index < 0)
 return false;
 }
 Object[] newElements = new Object;
 System.arraycopy(current, 0, newElements, 0, index);
 System.arraycopy(current, index + 1,
 newElements, index,
 len - index - 1);
 setArray(newElements);
 return true;
 }
}
</pre>
</div>
1、先获取当前元素的位置 2、获取元素对应的位置（注意如果有多个相同的元素这里只取第一个找到的元素o），我们记为index 3、然后跳转到另外一个remove 重载的方法中。 4、在重载方法中加入全局锁 5、取出最新的数组current 6、判断新数组的current和之前查找时用的数组是不是一个数组： <1>如果不是，说明有其他线程并发写操作了，此时开始重新找。 <2>首先在刚才index之前的元素都找一遍，如果找到，说明前移了，或者在index的更前方又插入该元素，此时这个新位置就是要移除的值。 <3>如果没找到又判断index>=新数组长度，那就说明是没有这个元素o了，直接就返回false了（因为上一步找的是index的位置，如果index都>=新数组长度，那么其实就已经遍历了）。 <4>如果还没有，那么判断index的位置是否仍等于元素o，如果是那么也判断找到了。 <5>如果还没有就判断index后边的位置是否有元素等于o 这里其实相当于分了3部分，如果发生了写操作就判断 index之前，index的位置，index之后，这三块分别有没有o出现。 7、直接new 一个长度为len-1的数组。然后分别把老数组的前后两部分拷贝到新数组中。
最后这个remove方法其实看的人觉得很繁琐，为什么他没有直接进来一把全局锁，然后遍历查找最后生成新数组即可。其实我觉得是可以的，jdk1.7也的确是这样的。但是在后续的版本中将预查找的部分移出了锁的范围。 锁的粒度更小。对写的操作更友好。
以上就是CopyOnWriteArrayList的内部核心实现了。 现在又回到最初的问题。(防盗连接：本文首发自http://www.cnblogs.com/jilodream/ )为什么元数组array的len始终和当前存储的元素数保持一致。而不是像arraylist等其他容器，给一定的预留空间方便，方便写呢？ 我认为主要基于以下考虑：
CopyOnWriteArrayList本质是为了读写分离更准确的说是为了读多写少的场景设计的。尽可能的压缩数组也为数组拷贝提供了优势。 array是及时变量，每次使用都是全新new一个出来，并不是在原有基础上写，没有必要为了性能预留空间。（核心原因）
另外的一个疑问为什么支持序列化，又要在array 前边修饰transient，防止它序列化？这是为何，我们序列化不就是为了转存数据么？ 这主要是由于CopyOnWriteArrayList是使用写单独拷贝的方式来处理并发的。而array前边又有volatile修饰，也就是说array一旦发生变化，那么所有使用的线程在下次使用时就会立刻感知到。倘若我们序列化进行中，突然发生了写操作，并已经完成，我是应该接着序列化（此时就有错误），还是重新序列化（性能太差）？ 因此又单独实现了该方法配合序列化用：
<div class="cnblogs_code">
<pre> private void writeObject(java.io.ObjectOutputStream s)
 throws java.io.IOException {

 s.defaultWriteObject();

 Object[] es = getArray();
 // Write out array length
 s.writeInt(es.length);

 // Write out all elements in the proper order.
 for (Object element : es)
 s.writeObject(element);
}</pre>
</div>
也就是我单独取出一份当前的数组放到es中，后边不管容器怎么写，我只序列化es中数据。
除此之外，队列的迭代也会有类似的问题。 我们知道队列的迭代，本质上就是使用迭代器依次的迭代元数据。而在CopyOnWriteArrayList中，和序列化相似，在迭代时，是将当前的元数组的引用指向到snapshot变量中。后续的迭代操作都是对该snapshot来操作的。 也就是说，在并发迭代时，我们迭代的数据是当前缓存的历史快照数据。如下：
<div class="cnblogs_code">
<pre> public Iterator<E> iterator() {
 return new COWIterator<E>(getArray(), 0);
}

static final class COWIterator<E> implements ListIterator<E> {
 /** Snapshot of the array */
 private final Object[] snapshot;
 /** Index of element to be returned by subsequent call to next.*/
 private int cursor;

 COWIterator(Object[] es, int initialCursor) {
 cursor = initialCursor;
 snapshot = es;
 }
....
}</pre>
</div>
可以看这个例子：
<div class="cnblogs_code">
<pre>public class CopyOnWriteArrayListLearn {
public static void main(String[] args) {
 CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList();
 list.add(1);
 list.add(2);
 list.add(3);
 list.add(4);
 for (Integer item : list) {
 list.add(item * 10);
 System.out.println("item:" + item);
 }
}
}</pre>
</div>
输出如下，只输出了迭代开启一瞬间的容器中的元素：
<div class="cnblogs_code">
<pre>Connected to the target VM, address: '127.0.0.1:61377', transport: 'socket'
item:1
item:2
item:3
item:4
Disconnected from the target VM, address: '127.0.0.1:61377', transport: 'socket'</pre>
</div>
同时，直接使用迭代器进行写操作时，(防盗连接：本文首发自http://www.cnblogs.com/jilodream/ )就会因为是快照数据而没有意义，所以源码中直接将迭代器的写操作抛出异常了：
<div class="cnblogs_code">
<pre> 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();
 }</pre>
</div>
 

</div>
<div id="MySignature" role="contentinfo">

如果你觉得写的不错，欢迎转载和点赞。
转载时请保留作者署名jilodream/王若伊_恩赐解脱（博客链接：http://www.cnblogs.com/jilodream/ 
来源：https://www.cnblogs.com/jilodream/p/19134525

頁: [1]

琼殿技术论坛's Archiver

CopyOnWriteArrayList 的故事--一起看看java原生的读写分离