什么是Fail Fast和Fail Safe？

最新推荐文章于 2024-03-19 14:03:11 发布

王小燊oom

最新推荐文章于 2024-03-19 14:03:11 发布

阅读量960

点赞数

分类专栏：随笔文章标签： java

本文链接：https://blog.csdn.net/Ives_WangShen/article/details/109521529

版权

随笔专栏收录该内容

13 篇文章 0 订阅

订阅专栏

这里是目录标题

1. Fail Fast

a. 概念

在Java中可以使用Iterator来遍历集合对象。当一个线程使用iterator遍历集合元素时，如果集合的数据被修改了(增、删、改)，支持Fail Fast的iterator会立刻抛出ConcurrentModificationExcepton异常。

支持Fail Fast迭代器的集合对象有ArrayList, HashMap, Vector等

b. 原理

fail-fast iterators使用了一个叫modCount的内部标识来标志集合数据是否被修改，每当集合的数据有修改，modCount就会被更新。每当iterator调用next()获取下一个集合元素时，都会检查modCount，如果发现在iterator被创建后，modCount值被修改了，就会抛出ConcurrentModificationExcepton异常。

// Java code to illustrate 
// Fail Fast Iterator in Java 
import java.util.HashMap; 
import java.util.Iterator; 
import java.util.Map; 
  
public class FailFastExample { 
    public static void main(String[] args) 
    { 
        Map<String, String> cityCode = new HashMap<String, String>(); 
        cityCode.put("Delhi", "India"); 
        cityCode.put("Moscow", "Russia"); 
        cityCode.put("New York", "USA"); 
  
        Iterator iterator = cityCode.keySet().iterator(); 
  
        while (iterator.hasNext()) { 
            System.out.println(cityCode.get(iterator.next())); 
  
            // adding an element to Map 
            // exception will be thrown on next call 
            // of next() method. 
            cityCode.put("Istanbul", "Turkey"); 
        } 
    } 
}

OutPut

India
Exception in thread “main” java.util.ConcurrentModificationException
at java.util.HashMap $H a s h I t e r a t o r . n e x t N o d e (H a s h M a p . j a v a : 1442) a t j a v a . u t i l . H a s h M a p$ KeyIterator.next(HashMap.java:1466)
at FailFastExample.main(FailFastExample.java:18)

c. 关注点

当使用iterator遍历集合时，如果集合元素被修改，就会抛出ConcurrentModificationException
迭代器使用原始集合遍历集合元素
这些迭代器不需要额外的内存空间
ArrayList, HashMap, Vector返回的迭代器支持Fail Fast

d. 注意

迭代器的快速失败行为不能得到保证，因为一般来说，在存在非同步并发修改时不可能做出任何硬性保证（比如类似ABA的问题可能会发生）。快速失败迭代器尽最大努力抛出ConcurrentModificationException。因此，如果要编写一个依赖于这个异常来保证其正确性的程序，那将是错误的:迭代器的快速失败行为应该仅用于检测错误。
如果通过Iterator remove()方法删除元素，则不会抛出异常。但是，在通过特定集合的remove()方法进行删除时，将抛出ConcurrentModificationException。下面是示例：

// Java code to demonstrate remove 
// case in Fail-fast iterators 
  
import java.util.ArrayList; 
import java.util.Iterator; 
  
public class FailFastExample { 
    public static void main(String[] args) 
    { 
        ArrayList<Integer> al = new ArrayList<>(); 
        al.add(1); 
        al.add(2); 
        al.add(3); 
        al.add(4); 
        al.add(5); 
  
        Iterator<Integer> itr = al.iterator(); 
        while (itr.hasNext()) { 
            if (itr.next() == 2) { 
                // will not throw Exception 
                itr.remove(); 
            } 
        } 
  
        System.out.println(al); 
  
        itr = al.iterator(); 
        while (itr.hasNext()) { 
            if (itr.next() == 3) { 
                // will throw Exception on 
                // next call of next() method 
                al.remove(3); 
            } 
        } 
    } 
}

OutPut

[1, 3, 4, 5]
Exception in thread “main” java.util.ConcurrentModificationException
at java.util.ArrayList $I t r . c h e c k F o r C o m o d i f i c a t i o n (A r r a y L i s t . j a v a : 901) a t j a v a . u t i l . A r r a y L i s t$ Itr.next(ArrayList.java:851)
at FailFastExample.main(FailFastExample.java:28)

2. Fail Safe

a. 概念

首先，在许多地方都没有给出故障安全这个术语，因为Java SE规范没有使用这个术语。我使用这个术语来演示快速失败迭代器和非失败快速迭代器之间的区别。这些迭代器复制内部集合(对象数组)并遍历复制的集合。对迭代器所做的任何结构修改都会影响复制的集合，而不是原始的集合。因此，原始集合在结构上保持不变。

当一个线程使用iterator遍历集合元素时，如果集合的数据被修改了(增、删、改)，支持Fail Safe的iterator不会异常。这是因为迭代器是在集合对象的拷贝上操作，而不是直接操作原集合对象。

java.util.concurrent下的包如CopyOnWriteArrayList, ConcurrentHashMap都是支持Fail Safe的。

b. 原理

使用原始集合的副本遍历集合的元素，比如：CopyOnWriteArrayList

// Java code to illustrate 
// Fail Safe Iterator in Java 
import java.util.concurrent.CopyOnWriteArrayList; 
import java.util.Iterator; 
  
class FailSafe { 
    public static void main(String args[]) 
    { 
        CopyOnWriteArrayList<Integer> list 
            = new CopyOnWriteArrayList<Integer>(new Integer[] { 1, 3, 5, 8 }); 
        Iterator itr = list.iterator(); 
        while (itr.hasNext()) { 
            Integer no = (Integer)itr.next(); 
            System.out.println(no); 
            if (no == 8) 
  
                // This will not print, 
                // hence it has created separate copy 
                list.add(14); 
        } 
    } 
}

OutPut

1
3
5
8

另外，那些不使用fail-fast概念的集合可能不需要在内存中创建克隆/快照来避免ConcurrentModificationException。例如，在ConcurrentHashMap的情况下，它不会对单独的副本进行操作，尽管它不是Fail Fast。相反，它的语义被官方规范描述为弱一致性(Java中的内存一致性属性)。

ConcurrentHashMap返回的迭代器是弱一致的。这意味着该迭代器可以容忍并发修改，在构造迭代器时遍历元素，并且可以(但不保证)在构造迭代器后反映对集合的修改。

// Java program to illustrate 
// Fail-Safe Iterator which 
// does not create separate copy 
import java.util.concurrent.ConcurrentHashMap; 
import java.util.Iterator; 
  
public class FailSafeItr { 
    public static void main(String[] args) 
    { 
  
        // Creating a ConcurrentHashMap 
        ConcurrentHashMap<String, Integer> map 
            = new ConcurrentHashMap<String, Integer>(); 
  
        map.put("ONE", 1); 
        map.put("TWO", 2); 
        map.put("THREE", 3); 
        map.put("FOUR", 4); 
  
        // Getting an Iterator from map 
        Iterator it = map.keySet().iterator(); 
  
        while (it.hasNext()) { 
            String key = (String)it.next(); 
            System.out.println(key + " : " + map.get(key)); 
  
            // This will reflect in iterator. 
            // Hence, it has not created separate copy 
            map.put("SEVEN", 7); 
        } 
    } 
}