fail-fast 快速失败机制

1、什么是 fail-fast

维基百科中关于fail-fast的解释：

在系统设计中，快速失效系统一种可以立即报告任何可能表明故障的情况的系统。快速失效系统通常设计用于停止正常操作，而不是试图继续可能存在缺陷的过程。这种设计通常会在操作中的多个点检查系统的状态，因此可以及早检测到任何故障。快速失败模块的职责是检测错误，然后让系统的下一个最高级别处理错误。

其实，这是一种理念，fail-fast就是在做系统设计的时候先考虑异常情况，一旦发生异常，直接停止并上报。

举一个最简单的fail-fast的例子：

public int divide(int divisor,int dividend){
    if(dividend == 0){
        throw new RuntimeException("dividend can't be null");
    }
    return divisor/dividend;
}

上面的代码是一个对两个整数做除法的方法，在divide方法中，我们对被除数做了个简单的检查，如果其值为0，那么就直接抛出一个异常，并明确提示异常原因。这其实就是fail-fast理念的实际应用。

这样做的好处就是可以预先识别出一些错误情况，一方面可以避免执行复杂的其他代码，另外一方面，这种异常情况被识别之后也可以针对性的做一些单独处理。

但是，Java 中的部分集合类中运用了fail-fast机制进行设计，一旦使用不当，触发fail-fast机制设计的代码，就会发生非预期情况。

2、集合类中的 fail-fast

我们通常说的Java中的fail-fast机制，默认指的是Java集合的一种错误检测机制。在使用迭代器对集合对象进行遍历的时候，如果 A 线程正在对集合进行遍历，此时 B 线程对集合进行修改（增加、删除），或者 A 线程在遍历过程中对集合进行修改，都会导致 A 线程抛出ConcurrentModificationException 异常。

示例：

单线程，在foreach 循环里对某些集合元素进行元素的 remove/add 操作的时候，就会触发fail-fast机制

public static void main(String[] args) {
    List<String> strList = new ArrayList<>();
    strList.add("AA");
    strList.add("aa");
    strList.add("BB");
    strList.add("CC");
    for (String str : strList) {
        if ("aa".equals(str)) {
            strList.remove(str);
        }
    }
    System.out.println(strList);
}

运行结果：

多线程，在一个线程读时，另一个线程写入list，读线程会快速失败

public class FailFastMultiThreadDemo {
    public static void main(String[] args) {
        List<String> strList = new ArrayList<>();
        strList.add("AA");
        strList.add("aa");
        strList.add("BB");
        strList.add("CC");
        strList.add("DD");
        strList.add("EE");
        new MyThread1(strList).start();
        new MyThread2(strList).start();
    }

    static class MyThread1 extends Thread {
        private List<String> list;

        public MyThread1(List<String> list) {
            this.list = list;
        }

        @Override
        public void run() {
            for (String str : list) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("MyThread1 " + str);
            }
        }
    }

    static class MyThread2 extends Thread {
        private List<String> list;

        public MyThread2(List<String> list) {
            this.list = list;
        }

        @Override
        public void run() {
            for (int i = 0; i < list.size(); i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if ("aa".equals(list.get(i))) {
                    list.remove(i);
                }
            }
            System.out.println("MyThread2 " + list);
        }
    }
}

运行结果：

3、原理分析 

将单线程实例代码编译后的的 .class 进行反编译，得到以下代码

public static void main(String[] args) {
	List<String> strList = new ArrayList();
	strList.add("AA");
	strList.add("aa");
	strList.add("BB");
	strList.add("CC");
	Iterator var2 = strList.iterator();

	while(var2.hasNext()) {
		String str = (String)var2.next();
		if ("aa".equals(str)) {
			strList.remove(str);
		}
	}

	System.out.println(strList);
}

可以发现，foreach其实是依赖了while循环和Iterator实现的。

通过以上代码的异常堆栈，可以跟踪到真正抛出异常的代码是：

at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)

该方法是在iterator.next()方法中调用的。看下该方法的实现：

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

如上，在该方法中对modCount和expectedModCount进行了比较，如果二者不想等，则抛出CMException。

那么，modCount和expectedModCount是什么？是什么原因导致他们的值不想等的呢？

modCount是ArrayList中的一个成员变量。它表示该集合实际被修改的次数。

expectedModCount 是 ArrayList中的一个内部类——Itr中的成员变量。

Iterator var2 = strList.iterator();

以上代码，即可得到一个 Itr类，该类实现了Iterator接口。

expectedModCount表示这个迭代器预期该集合被修改的次数。其值随着Itr被创建而初始化。只有通过迭代器对集合进行操作，该值才会改变。

那么，接着我们看下userNames.remove(userName);方法里面做了什么事情，为什么会导致expectedModCount和modCount的值不一样。

通过翻阅代码，我们也可以发现，remove方法核心逻辑如下：

private void fastRemove(int index) {
	modCount++;
	int numMoved = size - index - 1;
	if (numMoved > 0)
		System.arraycopy(elementData, index+1, elementData, index,
						 numMoved);
	elementData[--size] = null; // clear to let GC do its work
}

可以看到，remove方法只修改了modCount，并没有对expectedModCount做任何操作。

简单总结一下，之所以会抛出CMException异常，是因为代码中使用了增强for循环，而在增强for循环中，集合遍历是通过iterator进行的，但是元素的add/remove却是直接使用的集合类自己的方法。这就导致iterator在遍历的时候，会发现有一个元素在自己不知不觉的情况下就被删除/添加了，就会抛出一个异常，用来提示用户，可能发生了并发修改！

所以，在使用Java的集合类的时候，如果发生CMException，优先考虑fail-fast有关的情况，实际上这里并没有真的发生并发，只是Iterator使用了fail-fast的保护机制，只要他发现有某一次修改是未经过自己进行的，那么就会抛出异常。 

阿里巴巴开发手册中也有明确规定：

4、解决方式

使用普通 for 循环进行操作

我们说不能在foreach中进行，但是使用普通的for循环还是可以的，因为普通for循环并没有用到Iterator的遍历，所以也不会进行fail-fast的检验。

public static void main(String[] args) {
    List<String> strList = new ArrayList<>();
    strList.add("AA");
    strList.add("aa");
    strList.add("BB");
    strList.add("CC");
    for (int i = 0; i < strList.size(); i++) {
        if ("aa".equals(strList.get(i))) {
            strList.remove(i);
        }
    }
    System.out.println(strList);
}

但是删除多个元素时不建议使用，可能会漏删

直接使用 Iterator 进行操作

public static void main(String[] args) {
    List<String> strList = new ArrayList<>();
    strList.add("AA");
    strList.add("aa");
    strList.add("aa");
    strList.add("CC");
    Iterator<String> iterator = strList.iterator();
    while (iterator.hasNext()) {
        if ("aa".equals(iterator.next())) {
            iterator.remove();
        }
    }
    System.out.println(strList);
}

如果直接使用Iterator提供的remove方法，那么就可以修改expectedModCount的值。那么就不会再抛出异常了。其实现代码如下：

public void remove() {
	if (lastRet < 0)
		throw new IllegalStateException();
	checkForComodification();

	try {
		ArrayList.this.remove(lastRet);
		cursor = lastRet;
		lastRet = -1;
		expectedModCount = modCount;
	} catch (IndexOutOfBoundsException ex) {
		throw new ConcurrentModificationException();
	}
}

使用 Java 8 中提供的 filter 过滤

Java 8中可以把集合转换成流，对于流有一种filter操作， 可以对原始 Stream 进行某项测试，通过测试的元素被留下来生成一个新 Stream。

public static void main(String[] args) {
    List<String> strList = new ArrayList<>();
    strList.add("AA");
    strList.add("aa");
    strList.add("aa");
    strList.add("CC");
    strList = strList.stream().filter(e -> !"aa".equals(e)).collect(Collectors.toList());
    System.out.println(strList);
}

使用 fail-safe 的集合类

为了避免触发fail-fast机制导致异常，我们可以使用Java中提供的一些采用了fail-safe机制的集合类。

CopyOnWrite容器即写时复制的容器。通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。

java.util.concurrent包下的容器都是fail-safe的，可以在多线程下并发使用，并发修改。同时也可以在foreach中进行add/remove 。

public static void main(String[] args) {
    List<String> strList = new CopyOnWriteArrayList<>();
    strList.add("AA");
    strList.add("aa");
    strList.add("BB");
    strList.add("CC");
    Iterator<String> iterator = strList.iterator();
    for (String str : strList) {
        if ("aa".equals(str)) {
            strList.remove(str);
        }
    }
    System.out.println(strList);
    while (iterator.hasNext()) {
        System.out.println(iterator.next());
    }
}

以上代码，使用CopyOnWriteArrayList代替了ArrayList，就不会发生异常。

但是，虽然基于拷贝内容的优点是避免了ConcurrentModificationException，但同样地，迭代器并不能访问到修改后的内容。运行结果如下：

缺点：

1、内存占用问题：因为要复制集合对象，导致内存开销大

2、数据一致性问题：CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。所以如果你希望写入的的数据，马上能读到，请不要使用CopyOnWrite容器。

也可以使用增强 for 循环

如果，我们非常确定在一个集合中，某个即将删除的元素只包含一个的话， 也是可以使用增强for循环，只要在删除之后，立刻结束循环体，不要再继续进行遍历就可以了，也就是说不让代码执行到下一次的next方法。

public static void main(String[] args) {
    List<String> strList = new CopyOnWriteArrayList<>();
    strList.add("AA");
    strList.add("aa");
    strList.add("BB");
    strList.add("CC");
    for (String str : strList) {
        if ("aa".equals(str)) {
            strList.remove(str);
            break;
        }
    }
    System.out.println(strList);
}

5、总结

我们使用的增强for循环，其实是Java提供的语法糖，其实现原理是借助Iterator进行元素的遍历。

但是如果在遍历过程中，不通过Iterator，而是通过集合类自身的方法对集合进行添加/删除操作。那么在Iterator进行下一次的遍历时，经检测发现有一次集合的修改操作并未通过自身进行，那么可能是发生了并发被其他线程执行的，这时候就会抛出异常，来提示用户可能发生了并发修改，这就是所谓的fail-fast机制。