fail-safe 和 fail-fast 都是什么鬼？-蒲公英云

点击关注公众号，Java干货**及时送达**

你真的了解 `fail-fast` 和 `fail-safe` 吗？????

简介

java.util 包下的属于 fail-fast , 快速失败~ ????

java.util.concurrent 包下的属于 fail-safe ，安全失败~ ????

简单来说就是 fail-fast 在迭代时，如果发现该集合数据结构被改变 (modCount != expectedModCount)，就会抛出 ConcurrentModificationException

小伙伴们可以参考下下面的代码简单实验一下~ ????

`fail-fast` 实验代码

实验对象是 Hashtable，这里采用 jdk1.7 的写法 ~

因为博主还在研究下文中 ConcurrentHashMap 在7和8中有啥不一样 ????

class E implements Runnable{
    Hashtable<String, String> hashtable;
    public E(Hashtable<String, String> hashtable) {
        this.hashtable = hashtable;
    }
    private void add(Hashtable<String, String> hashtable){
        for (int i = 0; i < 10000000; i++) {
            hashtable.put("a",""+i);
        }
    }
    @Override
    public void run() {
        add(hashtable);
    }
}
public class D {
    public static void main(String[] args) {
        Hashtable<String, String> hashtable = new Hashtable<String, String>();
        hashtable.put("1","2");
        hashtable.put("2","2");
        hashtable.put("3","2");
        hashtable.put("4","2");
        hashtable.put("15","2");
        new Thread(new E(hashtable)).start();
        Set<Map.Entry<String, String>> entries = hashtable.entrySet();
        Iterator<Map.Entry<String, String>> iterator = entries.iterator();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        while (iterator.hasNext()){
            System.out.println(iterator.next());
            iterator.remove();
        }
    }
}

效果如图：

触发的原理：

当集合数据结构发生变化时，这两个值是不相等的，所以会抛出该异常~ 。

结论:

虽然 HashTable 是线程安全的 , 但是它有 fail-fast 机制，所以在多线程情况下进行迭代也不能去修改它的数据结构！

fail-fast 机制不允许并发修改！

`fail-safe` 实验代码

class E implements Runnable{
    ConcurrentHashMap<String, String> concurrentHashMap;
    public E(ConcurrentHashMap<String, String> concurrentHashMap) {
        this.concurrentHashMap = concurrentHashMap;
    }
    private void add( ConcurrentHashMap<String, String> concurrentHashMap){
        for (int i = 0; i < 100000; i++) {
            concurrentHashMap.put("a"+i,""+i);
        }
    }
    @Override
    public void run() {
        add(concurrentHashMap);
    }
}
public class D {
    public static void main(String[] args) {
        ConcurrentHashMap<String, String> concurrentHashMap = new ConcurrentHashMap<String, String>();
        concurrentHashMap.put("1","2");
        concurrentHashMap.put("2","2");
        concurrentHashMap.put("3","2");
        concurrentHashMap.put("4","2");
        concurrentHashMap.put("15","2");
        new Thread(new E(concurrentHashMap)).start();
        try {
            Thread.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Set<Map.Entry<String, String>> entries = concurrentHashMap.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            System.out.println(entry);
//            这里不用调用 iterator 去 remove
            concurrentHashMap.remove(entry.getKey());
        }
    }
}

效果如图：

代码运行讲解，线程A 往里加数据，线程B 遍历它的数据，并删除。

可以看到这里并没有报错~，但是它也不能保证遍历到所有的值 （可以理解为无法获取到最新的值）

有没有感受到一丝丝安全失败的感觉~ ????

哈哈哈它的特点就是 ???? 允许并发修改，不会抛出 ConcurrentModificationException ，但是无法保证拿到的是最新的值

不知道小伙伴们看完上面的实验代码有没有疑惑

(・∀・(・∀・(・∀・*)

#

为什么可以调用它自身的 `remove` 呢？

别急~ 我们先来看看使用这个迭代器中发生了什么？

源码走起~

小伙伴们可以看看下面四张图~

创建迭代器的过程

从图一可以看到会去创造一个 EntryIterator，而它又继承了 HashIterator ，在初始化时，会先调用父类的构造器。

从图三可以发现 HashIterator 在初始化时，会去调用 advance 方法（这里就不展开这个 concurrentHashMap结构啦~ ）这里的重点在最后一张图，它调用的是 UNSAFE.getObjectVolatile 。

它的作用是强制从主存中获取属性值。

小伙伴们可以自行对比下 HashMap 或者上面的 HashTable，他们都是直接拿到代码中定义的这个 Entry[]~。????

不知道小伙伴们 get 得到这个点没有~

哈哈哈容我唠叨唠叨一下~ ????

4ye 在网上搜这个 fail-fast 和 fail-safe 的区别时，看到下面这张图。

几乎都在说 fail-safe 会复制原来的集合，然后在复制出来的集合上进行操作，然后就说这样是不会抛出 ConcurrentModificationException 异常了。

可是这种说法是 不严谨的~ ???? 它描述的情况应该是针对这个 CopyOnWriteArrayList 或者 CopyOnWriteArraySet 的情况（下面的源码讲到~）

CopyOnWriteArrayList 源码

#

可以发现这里 snapshot 的指针是始终指向这个原数组的（当你创建迭代器的时候）

当你添加数据时，它会复制原来的数组，并在复制出来的数组上进行修改，

然后再设置进去，可以发现至始至终都没有修改到这个原数组，

所以迭代器中的数据是不受影响的~????

结论

fail-safe 也是得具体情况具体分析的。

如果是 CopyOnWriteArrayList 或者 CopyOnWriteArraySet ，就属于 复制原来的集合，然后在复制出来的集合上进行操作的情况 ，所以是不会抛出这个 ConcurrentModificationException 的。
如果是这个 concurrentHashMap 的，就比较硬核了~ ???? 它直接操作底层，调用UNSAFE.getObjectVolatile ，直接 强制从主存中获取属性值，也是不会抛出这个 ConcurrentModificationException 的。
并发下，无法保证遍历时拿到的是最新的值~