ArrayList和CopyOnWriteArrayList

前言

　　在开发过程中需要程序猿考虑线程安全的情况，java中ArrayList是线程不安全，对应的线程安全类是CopyOnWriteArrayList类，这里简单说一下这两个类。

1、ArrayList的遍历和fail-fast

　　对于集合的遍历通常有三种方式：for循环、foreach语法糖和Iterator迭代器，其实后两者是一样的，只不过写法不同而已，foreach其实也是使用了迭代器来实现的。我们经常有这样的需求，在遍历过程中需要对集合的元素进行增加或修改操作，这里先贴上一个错误的方式代码

    List<String> list = new ArrayList<>();
    list.add("a");
    list.add("b");
    list.add("c");
    list.add("d");
    for (int i = 0;i < list.size(); i++ ) {        
        if("b".equals(list.get(i))){
            list.remove(i);
    }else{
            System.out.println(list.get(i));//or do something
        }    
    }                    

　　我们预期的打印结果是a、c、d，但实际结果却是a、d，元素c丢失了。造成这个问题的原因就是，当list遍历到第二个元素b的时候，调用remove方法，这时候list的结构发生了变化，长度减少了1，而此时i的值依然从1自增到了2，所以下一次打印结果就是get(2)。在遍历集合的时候对集合进行操作时不推荐使用传统的for循环方式，接下来我们再贴上foreach语法糖的代码

     for (String str : list) {
        if("b".equals(str)){
            list.remove(str);
        }else{
            System.out.println(str);
        }
    }

　　运行一下发现报错了，抛出了这个异常java.util.ConcurrentModificationException，这个是ArrayList的fail-fast机制。那什么是fail-fast呢？我们知道ArrayList是线程不安全的，换句话说，如果有两个线程，一个线程对ArrayList遍历，另一个线程对ArrayList进行修改操作，那ArrayList会尽力抛出异常，告诉我们同时操作是不允许的。我们看一下ArrayList是如何抛出这个异常的，前面说过，foreach语法糖其实就是Iterator迭代器，我们看到在ArrayList类中有个内部类Itr，这个类中有个变量叫expectedModCount，它的初始值等于ArrayList类中的modCount，当调用迭代器中的next()方法时会比较这两个变量的值是否相等，如果不相等则抛出上述的异常。ArrayList每次的修改操作都会对modCount进行自增操作，所以每次调用remove()方法，modCount值都会发生变化，导致与expectedModCount不相等，从而抛出异常。

    public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // Let gc do its work

        return oldValue;
    }

　　这个是ArrayList的remove方法，这里的modCount进行了自增的操作。

    @SuppressWarnings("unchecked")
    public E next() {
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }

　　这个是内部类Itr的next()方法，里面调用了checkForComodification()方法，这个方法就是校验modCount和expectedModCount是否相等。

    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }

　　那么对于上述的需求我们到底应该怎么做呢，这里推荐大家使用Iterator迭代器来实现，在迭代过程中实现元素的remove操作

    Iterator<String> it = list.iterator();
    while(it.hasNext()){
        String str = it.next();
        if("b".equals(str)){
            it.remove();
        }else{
            System.out.println(str);
        }
    }

　　我们发现这是可以的，而且结果也是正确的，理由就是在Itr中的remove()方法会将modCount和expectedModCount设置相等。

2、CopyOnWriteArrayList

　　上面说了fail-fast，这里简单说一说fail-safe。对于CopyOnWriteArrayList来说，一个线程遍历它，一个线程修改它的元素时不会出现上面的问题，fail-safe的原理就是每次对元素的修改都会在副本上进行，也就是说CopyOnWriteArrayList对于set、remove、add等请求会先将集合做一个复制，然后所有的增删改操作均在复制的集合上操作，然后再将结果写回来。我们看一下CopyOnWriteArrayList的源码

    private volatile transient Object[] array;

　　在CopyOnWriteArrayList中这样一个属性array，它是真正存储数据的地方，这里再看一下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();
        }
    }

　　先进行加锁操作，然后获取数组，其实就是获取array属性的值，复制一份进行新增操作，再写回array属性，最后释放锁。其实我们从名字就可以猜测出来其原理，copyonwrite在redis持久化fork子进程时也有类似的应用。关于CopyOnWriteArrayList就简单说这么多，有不对的地方希望大家及时指出！