一、概述
CopyOnWriteArrayList是基于写时复制技术实现的，适用于读多写少场景下的线程安全的并发容器。读操作永远不会加锁，读读、读写都不会冲突，只有写写需要等待。写操作时，为了不影响其它线程的读取，它会进行一次自我复制，待数据写入完成后再替换array数组。array数组是被volatile修饰的，它被修改后可以被其他线程立刻发现。
public class copyOnwriteArrayList<E>
implements List<E>,RandomAccess，Cloneable，java.io.Serializable {
//加锁: ReentrantLock
final transient ReentrantLock lock = new ReentrantLock( ) ;
// volatile:保证可见性
private transient volatile object[ ] array;
//获取数组
final object[] getArray() ireturn array ;
}
//存入数组
final void setArray(object[ ] a) iarray = a;
}
//无参构造方法:初始化数组，容量为日public CopyOnwriteArrayList( ) i
setArray( new object[e]);
}
//有参构造方法:传入集合
public CopyOnwriteArrayList(collection< ? extends E> c) {
object[] elements;
//判断传入的集合是否是CopyOnwriteArrayList类型if (c.getclass() == copyonwriteArrayList.class)
//获取数组
elements = ((copyOnwriteArrayList<?>)c).getArray();else i
//将集合转为数组
elements = c.toArray();
// c.toArray might (incorrectly) not return object[] (see 6260652)1/判断数组是否是object[]
if (elements.getclass() i= object[].class)
//复制数组
elements = Arrays.copyof(elements，elements.length，object[ ].c1
}
setArray(elements) ;
}
setArray(elements ) ;
}二、类图
- 实现了RandomAccess接口，代表它支持快速随机访问，因为它底层数据结构是数组，支持通过下标快速访问；
- 实现了Cloneable接口，代表它支持克隆，使用的是浅拷贝模式；
- 实现了List接口，代表它是一个有序的列表容器，支持迭代遍历等操作。
三、核心方法
1.add()
向容器中添加元素时，需要竞争锁，同一时刻最多只有一个线程可以操作。因为是写时复制，写入数据时不应该影响其他线程的读取，因此不会直接在array数组上操作，而是拷贝一个新的数组，元素设置完成后再覆盖旧数组。
public boolean add(E e) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
// 拷贝一个长度+1的数组，将元素放到末尾
Object[] newElements = Arrays.copyOf(elements, len + 1);
// 填充要追加的元素e
newElements[len] = e;
// 覆盖旧数组
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}2.set()
set方法用来给指定下标设置值，同时会返回旧值。它也是一个写入操作，因此也需要竞争到锁才能执行。为了不影响其它线程读取，它会拷贝一个同样长度的新数组，然后做数据拷贝，在新数组上完成新值的设置，最终再写回array。
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;
// 拷贝一个一样的数组，替换下标元素，并写入array
Object[] newElements = Arrays.copyOf(elements, len);
newElements[index] = element;
setArray(newElements);
} else {
// 即使元素没有变化，也要写入array，确保volatile的写语义
// Not quite a no-op; ensures volatile write semantics
setArray(elements);
}
return oldValue;
} finally {
lock.unlock();
}
}3.remove()
remove也是写操作，只有竞争到锁的线程才能执行。它先是取出对应下标的旧元素，然后新建了一个原数组长度减1的新数组，完成数据拷贝后，再写回array，整个过程依然不影响其它线程读。
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)
// 删除的是最后一个元素，直接拷贝一个长度-1的数组写回array即可
setArray(Arrays.copyOf(elements, len - 1));
else {
// 删除的是中间元素，拷贝一个长度-1的数组
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();
}
}4.get()
通过下标获取元素，直接从array数组中取。因为是写时复制的，可能在访问时已经有新的元素加入，或者有元素被删除，这是会存在延迟的，不是实时的，这是它的一个缺点。
public E get(int index) {
// getArray()获取的就是array
return get(getArray(), index);
}
private E get(Object[] a, int index) {
return (E) a[index];
}5.size()
获取元素的数量直接取数组的长度即可。因为CopyOnWriteArrayList的数组是不可变数组，它始终是一个被填充满的数组对象，没有扩容的操作，因此也没有必要像ArrayList一样，额外使用一个int size来记录数量。
public int size() {
return getArray().length;
}四、总结
CopyOnWriteArrayList 具有以下特性：
- 在保证并发读取的前提下，确保了写入时的线程安全；
- 由于每次写入操作时，进行了Copy复制原数组，所以无需扩容；
- 适合读多写少的应用场景。由于 add() 、 set() 、 remove() 等修改操作需要复制整 个数组，所以会有内存开销大的问题；
- CopyOnWriteArrayList 由于只在写入时加锁，所以只能保证数据的最终一致性，不能 保证数据的实时一致性。
到此这篇关于Java CopyOnWriteArrayList源码超详细分析的文章就介绍到这了,更多相关Java CopyOnWriteArrayList内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！
