Java 经典面试题：聊一聊 JUC 下的 CopyOnWriteArrayList

ArrayList 是咱们经常使用的工具类之一，可是在多线程的状况下，ArrayList 做为共享变量时，并非线程安全的。主要有如下两个缘由：

• 一、 ArrayList 自身的 elementData、size、modCount 在进行操做的时候，都没有加锁；
• 二、这些变量没有被 volatile 修饰，在多线程的状况下，对这些变量操做可能会出现值被覆盖的状况；

若是咱们想在多线程状况下使用 ArrayList 怎么办？有如下几种办法：

• 使用 Collections.SynchronizedList ；
• 使用 JUC 下的 CopyOnWriteArrayList；

先来看看 SynchronizedLis，Collections 其实就是对 ArrayList 进行了一个加锁包装，这个从源码中能够看出;

...部分源码，完整源码请查看 JDK 源码...
public void add(int index, E element) {
    synchronized (mutex) {list.add(index, element);}
}
public E remove(int index) {
    synchronized (mutex) {return list.remove(index);}
}
复制代码

对于 Collections.SynchronizedList 比较简单，就是锁包装了一下，就很少说了~

CopyOnWriteArrayList 也是 JUC 下面的一个并发容器类。不知道你发现没有，但凡你经常使用的集合类，在 JUC 下基本上均可以找到一个并发类，好比 hashMap 有对应的 ConcurrentHashMap。

CopyOnWriteArrayList 跟 ArrayList 在总体架构上并无什么区别，底层都是基于数组实现的。不一样的地方大概有两点：

• 底层数组被 volatile 关键字修饰；
• 对数组进行数据变动时加锁；

CopyOnWriteArrayList 的加锁操做跟 Collections.SynchronizedList 简单的加锁还不同，CopyOnWriteArrayList 中的加锁过程仍是很是值得学习的。CopyOnWriteArrayList 的加锁过程，大概能够归纳为如下四步：

• 一、加锁；
• 二、从原数组中拷贝出新数组；
• 三、在新数组上进行操做，并把新数组赋值给数组容器；
• 四、解锁；

结合源码来深刻了解 CopyOnWriteArrayList 的并发实现，咱们选择 ArrayList 最简单的将元素新增数组尾部的操做来分析实现过程，源码以下：

/** * Appends the specified element to the end of this list. * * @param e element to be appended to this list * @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 就是经过加锁来讲实现容器安全的，可能你会有疑问，为何引入一个新数组，数组的拷贝仍是消耗时间的，直接在原数组上操做不就行了吗？。主要缘由有如下两点：

• volatile 关键字修饰的是数组，若是咱们简单的在原来数组上修改其中某几个元素的值，是没法触发可见性的，咱们必须经过修改数组的内存地址才行，也就说要对数组进行从新赋值才行。
• 在新的数组上进行拷贝，对老数组没有任何影响，只有新数组彻底拷贝完成以后，外部才能访问到，下降了在赋值过程当中，老数组数据变更的影响。好比经典的 ConcurrentModificationException 异常问题。

其余的新增方法就本身去查看源码了，相差很少，基本上是同样的。对数组的删除跟新增都是差很少，不一样的地方是在删除了时候，赋值给新数组时会出现不一样的选择策略。我把源码贴上：

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();
    }
}
复制代码

CopyOnWriteArrayList 还有其余的方法，在这里我就不过多介绍了。根据大家本身的疑问去扒一扒 CopyOnWriteArrayList 的源码就知道了，整体来讲 CopyOnWriteArrayList 并不难，甚至感受比 ArrayList 要简单。

总结一下：CopyOnWriteArrayList 是安全的并发容器，有如下两个特色：

• 一、对数组的写操做加锁，读操做不加锁；
• 二、经过加锁 + 数组拷贝+ volatile 来保证线程安全；

欢迎关注公众号【互联网平头哥】，一块儿成长，一块儿进步~。