前言
今天我们来学习一下CopyOnWriteArrayList这个比ArrayList更安全的集合,同时带着以下几个问题去分析源码。
- CopyOnWriteArrayList如何保证线程安全?
- CopyOnWriteArrayList有什么优缺点吗?
- CopyOnWriteArrayList与ArrayList有什么区别吗?
- 了解CopyOnWriteArraySet吗?
继承关系
public class CopyOnWriteArrayList<E>
implements List<E>, RandomAccess, Cloneable,
java.io.Serializable {
//......
}
复制代码
首先我们来看一下CopyOnWriteArrayList的继承关系,从源码中可以看出它分别实现了List、RandomAccess、Cloneable以及Serializable,对于我们比较熟悉的应该是List和Serializable了。
核心字段
//可以看出这是重入锁
final transient ReentrantLock lock = new ReentrantLock();
//底层数组,可以看出用了volatile
private transient volatile Object[] array;
复制代码
通过以上两个核心字段,可以猜出CopyOnWriteArrayList内部进行了加锁来保证线程安全。那么它到底是如何实现的呢?我们继续往下分析。
构造方法
/**
* 默认构造方法,初始化了一个空数组
*/
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();
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elements.getClass() != Object[].class)
elements = Arrays.copyOf(elements, elements.length, Object[].class);
}
setArray(elements);
}
public CopyOnWriteArrayList(E[] toCopyIn) {
setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
}
复制代码
修改
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;
//设置array为newElements
setArray(newElements);
} else {
// Not quite a no-op; ensures volatile write semantics
setArray(elements);
}
return oldValue;
} finally {
//解锁
lock.unlock();
}
}
复制代码
可以看出在写入数据时通过加锁来保证线程安全,并且通过复制一个新数组。然后修改新数组中index对应的Value值,最后将新数组赋值给CopyOnWriteArrayList的底层数组array,也可以说是将array数组指向新数组,如下图:
对于CopyOnWriteArrayList的set()方法,我们可以这样理解。- 获取旧数组
- 通过复制旧数组创建新数组
- 在新数组中进行修改
- array指向新数组
添加
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();
}
}
复制代码
可以看出与set()方法类似,也是通过加锁的方式来保证线程安全。然后创建一个新数组来添加元素,最后将新数组赋值给array。
获取
public E get(int index) {
return get(getArray(), index);
}
@SuppressWarnings("unchecked")
private E get(Object[] a, int index) {
return (E) a[index];
}
复制代码
从get()方法源码中可以看出 ,在从CopyOnWriteArrayList获取元素时并没有进行加锁。那么我们就要思考一个问题了,如果当写入数据时,在没有写完数据的情况下。再去读取数据,那么我们能准确的获得数据吗?而且重点是在get()方法中,是直接对底层数组array进行操作的。那就意味着在我们读取数据时,有可能获得的是旧数据。也就是说CopyOnWriteArrayList并不能保证数据的实时性,主要原因可以从以下几点来思考。
- 在get()方法并没有进行加锁
- 读取的是底层数组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)
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();
}
}
复制代码
可以看出remove()方法也是一样的,通过加锁来保证线程安全。
其他方法
/**
* 获取底层数组
*/
final Object[] getArray() {
return array;
}
/**
* 设置底层数组
*/
final void setArray(Object[] a) {
array = a;
}
/**
* 获取数组大小
*/
public int size() {
return getArray().length;
}
/**
* 判断数组是否为空
*/
public boolean isEmpty() {
return size() == 0;
}
复制代码
优点与缺点
通过查看源码,我们可以看出CopyOnWriteArrayList最大的优点就是线程安全,也是最突出的优点。它在读取操作时没有加锁,只有当进行写入操作时才会加锁。这也体现出了CopyOnWriteArrayList的一个缺点,那就是无法读取实时数据。因为可能当写操作还没有完成时,就进行了读取操作,那么读取的将是旧数据。
CopyOnWriteArraySet
接下来我们来简单了解一下CopyOnWriteArrayList的表兄弟CopyOnWriteArraySet,主要源码如下。
private final CopyOnWriteArrayList<E> al;
public CopyOnWriteArraySet() {
al = new CopyOnWriteArrayList<E>();
}
复制代码
通过构造方法就可以看出初始化了一个CopyOnWriteArrayList,也就是说CopyOnWriteArraySet内部是用CopyOnWriteArrayList来实现的,我们再来看一下其他几个方法。
public boolean add(E e) {
return al.addIfAbsent(e);
}
public boolean remove(Object o) {
return al.remove(o);
}
复制代码
可以看出add()和remove()都是通过CopyOnWriteArrayList来实现。
总结
通过分析源码,我们了解了CopyOnWriteArrayList的内部实现,以及它是如何保证线程安全的,还了解一下CopyOnWriteArraySet。