java中fail-fast 和 fail-safe的区别(同步修改)

java中fail-fast 和 fail-safe的区别

Fail Fast Vs Fail Safe Iterator In Java : Java Developer Interview Questions

Java 集合系列04之 fail-fast总结(通过ArrayList来说明fail-fast的原理、解决办法)

什么是同步修改（并发修改）？

当一个或多个线程正在遍历一个集合Collection，此时另一个线程修改了这个集合的内容（添加，删除或者修改）。这就是同步修改（并发修改）

什么是 fail-fast 机制?

fail-fast机制在遍历一个集合时，当集合结构被修改，会抛出Concurrent Modification Exception。
fail-fast会在以下两种情况下抛出ConcurrentModificationException
（1）单线程环境
集合被创建后，在遍历它的过程中修改了结构。
注意 remove()方法会让expectModcount和modcount 相等，所以是不会抛出这个异常。
（2）多线程环境
当一个线程在遍历这个集合，而另一个线程对这个集合的结构进行了修改。

注意，迭代器的快速失败行为无法得到保证，因为一般来说，不可能对是否出现不同步并发修改做出任何硬性保证。快速失败迭代器会尽最大努力抛出 ConcurrentModificationException。因此，为提高这类迭代器的正确性而编写一个依赖于此异常的程序是错误的做法：迭代器的快速失败行为应该仅用于检测 bug。

fail-fast机制是如何检测的？

迭代器在遍历过程中是直接访问内部数据的，因此内部的数据在遍历的过程中无法被修改。为了保证不被修改，迭代器内部维护了一个标记 “mode” ，当集合结构改变（添加删除或者修改），标记"mode"会被修改，而迭代器每次的hasNext()和next()方法都会检查该"mode"是否被改变，当检测到被修改时，抛出Concurrent Modification Exception。
下面看看ArrayList迭代器部分的源码

private class Itr implements Iterator<E> {
        int cursor;
        int lastRet = -1;
        //可以看到它的标记“mode”为 expectedModeCount
        int expectedModCount = ArrayList.this.modCount;
 
        public boolean hasNext() {
            return (this.cursor != ArrayList.this.size);
        }
 
        public E next() {
            checkForComodification();
            /** 省略此处代码 */
        }
 
        public void remove() {
            if (this.lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();
            /** 省略此处代码 */
        }
 
        final void checkForComodification() {
            if (ArrayList.this.modCount == this.expectedModCount)
                return;
            throw new ConcurrentModificationException();
        }
    }

fail-safe机制

fail-safe任何对集合结构的修改都会在一个复制的集合上进行修改，因此不会抛出ConcurrentModificationException
fail-safe机制有两个问题
（1）需要复制集合，产生大量的无效对象，开销大
（2）无法保证读取的数据是目前原始数据结构中的数据。

fail-fast 和 fail-safe的例子

package cn.lee.demo;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class FailFastOrFailSafeExample {

    public static void main(String[] args) {
        Map<String,String> premiumPhone = new HashMap<String,String>();//fail-fast
        //ConcurrentHashMap<String, String> premiumPhone = new ConcurrentHashMap<String, String>();//fail-safe
        premiumPhone.put("Apple", "iPhone");
        premiumPhone.put("HTC", "HTC one");
        premiumPhone.put("Samsung", "S5");

        Iterator iterator = premiumPhone.keySet().iterator();

        while (iterator.hasNext()) {
            System.out.println(premiumPhone.get(iterator.next()));
            premiumPhone.put("Sony", "Xperia Z");
        }

    }

}

Output

iPhone
Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.HashMap$HashIterator.nextEntry(HashMap.java:922)
	at java.util.HashMap$KeyIterator.next(HashMap.java:956)
	at cn.lee.demo.FailFastOrFailSafeExample.main(FailFastOrFailSafeExample.java:20)

Process finished with exit code 1

fail-fast和fail-safe对比

	Fail Fast Iterator	Fail Safe Iterator
Throw ConcurrentModification Exception（抛出异常）	是	否
Clone object （克隆对象）	否	是
Example	HashMap,Vector,ArrayList,HashSet	CopyOnWriteArrayList,ConcurrentHashMap