ArrayList和CopyOnWriteArrayList使用iterator迭代器出现的一些问题

看源码突然发现一个神奇的地方，关于线程不安全的ArrayList和线程安全的CopyOnWriteArrayList使用iterator迭代器出现的一些问题。

ArrayList的分析

我们知道ArrayList是线程不安全的集合类，但是在单线程环境下，使用iterator进行遍历修改的时候会出现 java.util.ConcurrentModificationException并发修改异常，这是为什么呢？

原来是由于ArrayList实现了fail-fast机制，什么是fail-fast机制呢？

如果当一个线程通过获取集合类的 iterator 迭代器去遍历集合的过程中，该集合的内容被改变了，那么就会抛 ConcurrentModificationException异常。

我们来看一个例子：

import java.util.*;
public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("1w");
        list.add("2w");
        list.add("3w");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            String cur = iterator.next();
            if(cur=="1w"){
                list.remove(cur);
            }
            System.out.println(cur);
        }
    }
}

该程序会报出ConcurrentModificationException异常：

这就是fail-fast机制在单线程环境下的体现。但是原理是是什么呢？

这里涉及到我们在ArrayList的源码中有一个变量modCount，该变量表明当前ArrayList结构修改的次数。而ArrayList中重新定义了一个Itr类实现了Iterator接口，在该接口中有一个变量expectedModCount，迭代以前expectedModCount等于modCount。

但是我们在迭代的过程中在list中增加或者删除数据导致了list结构有所变化，modCount也变化了，不再等于expectedModCount。导致利用迭代器的next方法的时候，判断两者不相等，从而出现并发修改异常：

调用迭代器的next方法，会调用checkForComodification()方法进行一个检验：

既然了解了fail-fast的原理了，那么下面的例子出现问题我们应该也能知道是怎么回事了：

import java.util.*;
public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("1w");
        list.add("2w");
        Iterator<String> iterator = list.iterator();
        list.add("3w");
        while (iterator.hasNext()){
            String cur = iterator.next();
            System.out.println(cur);
        }
    }
}

就是因为在获取迭代器之后，对list的结构做了修改，导致expectedModCount与modCount不相等，之后调用next()从而检验两者是否相等，从而报出异常。

CopyOnWriteArrayList分析

从上面的程序，我们来分析一下CopyOnWriteArrayList这个线程安全的集合类，我们首先来看看CopyOnWriteArrayList是怎么保证线程安全的，顾名思义所谓写时复制ArrayList，就是写操作的时候复制一个新数组进行修改，将读写分离，读操作不上锁，写操作线程不安全要上锁，下面是add方法的源码：

/** The array, accessed only via getArray/setArray. */
private transient volatile Object[] array;//其中用来存储数据的array数组使用volatile修饰，保证可见性，并且只能通过getArray和setArray方法设置

public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();//首先使用ReentrantLock进行上锁操作，只允许一个线程进行操作
    try {
        Object[] elements = getArray();//获取旧数组
        int len = elements.length;//获取旧数组的长度
        Object[] newElements = Arrays.copyOf(elements, len + 1);//创建一个新数组，长度为旧数组的长度+1，并且前面元素和旧数组一样
        newElements[len] = e;//将添加元素放入新数组最后一位
        setArray(newElements);//利用新数组覆盖旧数组
        return true;
    } finally {
        lock.unlock();//解锁
    }
}

那么接下来我们看看使用CopyOnWriteArrayList的iterator迭代器，并且在迭代过程中修改会出现什么问题：

import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;
public class Test {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        list.add("1w");
        list.add("2w");
        Iterator<String> iterator = list.iterator();
        list.add("3w");
        while (iterator.hasNext()){
            String cur = iterator.next();
            System.out.println(cur);
        }
    }
}

输出结果：

1w
2w

没有出现并发修改异常，不愧是线程安全的；但是只有1w和2w，我们添加3w去哪里了呢？我们来看看CopyOnWriteArrayList的迭代器：

原来他是将getArray()获取到的数组作为了一个快照，存储起来了，之后遍历都是从该快照中进行迭代：

这样应该就能够理解为什么我们的3w消失了，那么3w到底存入了list中吗？还是丢失了？我们代码验证一下：

import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;
public class Test {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        list.add("1w");
        list.add("2w");
        Iterator<String> iterator = list.iterator();
        list.add("3w");
        while (iterator.hasNext()){
            String cur = iterator.next();
            System.out.println(cur);
        }
        System.out.println(list);
    }
}

输出结果：

1w
2w
[1w, 2w, 3w]

结果还是存到了list中的。