java中快速失败(fail-fast)和安全失败(fail-safe)的区别是什么？

阳光穿透心脏的1/2处 2024-05-01 16:01 4阅读 0赞

**一：快速失败（fail—fast）**

在用迭代器遍历一个集合对象时，如果遍历过程中对集合对象的内容进行了修改（增加、删除、修改），则会抛出Concurrent Modification Exception。

原理：迭代器在遍历时直接访问集合中的内容，并且在遍历过程中使用一个 modCount 变量。集合在被遍历期间如果内容发生变化，就会改变modCount的值。每当迭代器使用hashNext()/next()遍历下一个元素之前，都会检测modCount变量是否为expectedmodCount值，是的话就返回遍历；否则抛出异常，终止遍历。

注意：这里异常的抛出条件是检测到 modCount！=expectedmodCount 这个条件。如果集合发生变化时修改modCount值刚好又设置为了expectedmodCount值，则异常不会抛出。因此，不能依赖于这个异常是否抛出而进行并发操作的编程，这个异常只建议用于检测并发修改的bug。

场景：java.util包下的集合类都是快速失败的，不能在多线程下发生并发修改（迭代过程中被修改）。

**二：安全失败（fail—safe）**

采用安全失败机制的集合容器，在遍历时不是直接在集合内容上访问的，而是先复制原有集合内容，在拷贝的集合上进行遍历。

原理：由于迭代时是对原集合的拷贝进行遍历，所以在遍历过程中对原集合所作的修改并不能被迭代器检测到，所以不会触发ConcurrentModificationException。

**本人验证后不同于原作者：不触发ConcurrentModificationException的原因是fail-safe机制不会检测modCount和expectedmodCount是否相等，而且并不是迭代时是对原集合的拷贝进行遍历，迭代时只是拿到原集合的引用，而非内容**

缺点：基于拷贝内容的优点是避免了Concurrent Modification Exception，但同样地，迭代器并不能访问到修改后的内容，即：迭代器遍历的是开始遍历那一刻拿到的集合拷贝，在遍历期间原集合发生的修改迭代器是不知道的。

场景：java.util.concurrent包下的容器都是安全失败，可以在多线程下并发使用，并发修改。

在我们详细讨论这两种机制的区别之前，首先得先了解并发修改。

1.什么是同步修改？

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

2.什么是 fail-fast 机制?

fail-fast机制在遍历一个集合时，当集合结构被修改，会抛出Concurrent Modification Exception。

fail-fast会在以下两种情况下抛出ConcurrentModificationException

（1）单线程环境

集合被创建后，在遍历它的过程中修改了结构。

注意 remove()方法会让expectModcount和modcount 相等，所以是不会抛出这个异常。

（2）多线程环境

当一个线程在遍历这个集合，而另一个线程对这个集合的结构进行了修改。

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

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

下面看看ArrayList迭代器部分的源码

>     /**
>      * An optimized version of AbstractList.Itr
>      */
>     private class Itr implements Iterator<E> {
>         int cursor;       // index of next element to return
>         int lastRet = -1; // index of last element returned; -1 if no such
>         int expectedModCount = modCount;
>     
>         Itr() {}
>     
>         public boolean hasNext() {
>             return cursor != size;
>         }
>     
>         @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];
>         }
>     
>         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();
>             }
>         }
>     
>         @Override
>         @SuppressWarnings("unchecked")
>         public void forEachRemaining(Consumer<? super E> consumer) {
>             Objects.requireNonNull(consumer);
>             final int size = ArrayList.this.size;
>             int i = cursor;
>             if (i >= size) {
>                 return;
>             }
>             final Object[] elementData = ArrayList.this.elementData;
>             if (i >= elementData.length) {
>                 throw new ConcurrentModificationException();
>             }
>             while (i != size && modCount == expectedModCount) {
>                 consumer.accept((E) elementData[i++]);
>             }
>             // update once at end of iteration to reduce heap write traffic
>             cursor = i;
>             lastRet = i - 1;
>             checkForComodification();
>         }
>     
>         final void checkForComodification() {
>             if (modCount != expectedModCount)
>                 throw new ConcurrentModificationException();
>         }
>     }

可以看到它的标记“mode”为 expectedModeCount

4. fail-safe机制

fail-safe任何对集合结构的修改都会在一个复制的集合上进行修改（经验证，并不是复制了集合，只是复制了引用，下面fail-safe（1）例子有佐证），因此不会抛出ConcurrentModificationException

**你可以并发读取，不会抛出异常，但是不保证你遍历读取的值和当前集合对象的状态是一致的**！这才是安全失败的含义

fail-safe机制有两个问题

（1）需要复制集合，产生大量的无效对象，开销大

（2）无法保证读取的数据是目前原始数据结构中的数据。

5 fail-fast 和 fail-safe的例子

fail-fast（1）例子：

> import java.util.HashMap;  
> import java.util.Iterator;  
> import java.util.Map;  
>   
> public class FailFastExample  
> \{  
>   
>   
> public static void main(String\[\] args)  
> \{  
> Map<String,String> premiumPhone = new HashMap<String,String>();  
> 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");  
> \}  
>   
> \}  
>   
> \}

> 输出
> 
> iPhone  
> Exception in thread "main" java.util.ConcurrentModificationException  
> at java.util.HashMap$HashIterator.nextEntry(Unknown Source)  
> at java.util.HashMap$KeyIterator.next(Unknown Source)  
> at FailFastExample.main(FailFastExample.java:20)

fail-safe（1）例子

> import java.util.concurrent.ConcurrentHashMap;  
> import java.util.Iterator;  
>   
>   
> public class FailSafeExample  
> \{  
>   
>   
> public static void main(String\[\] args)  
> \{  
> ConcurrentHashMap<String,String> premiumPhone =  
> new ConcurrentHashMap<String,String>();  
> 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");  
> \}  
>   
> \}  
>   
> \}

输出

>     S5
>     HTC one
>     iPhone

fail-safe（2）例子

>     ConcurrentHashMap<String, String> premiumPhone = new ConcurrentHashMap<String, String>();
>           premiumPhone.put("Apple", "iPhone");
>           premiumPhone.put("HTC", "HTC one");
>           premiumPhone.put("Sony", "S5");
>     
>           Iterator iterator = premiumPhone.keySet().iterator();
>     
>           while (iterator.hasNext())
>           {
>              System.out.println(premiumPhone.get(iterator.next()));
>              premiumPhone.put("Samsung", "Xperia Z");
>     //       premiumPhone.remove("Sony");
>           }
> 
> 输出结果：
> 
> S5  
> iPhone  
> HTC one  
> Xperia Z

6. fail-fast和 fail-safe 的区别

<table> 
 <tbody> 
  <tr> 
   <th>&nbsp;</th> 
   <th>Fail Fast Iterator</th> 
   <th>Fail Safe Iterator</th> 
  </tr> 
  <tr> 
   <td>Throw ConcurrentModification Exception</td> 
   <td>Yes</td> 
   <td>No</td> 
  </tr> 
  <tr> 
   <td>Clone object</td> 
   <td>No</td> 
   <td>Yes</td> 
  </tr> 
  <tr> 
   <td>Memory Overhead</td> 
   <td>No</td> 
   <td>Yes</td> 
  </tr> 
  <tr> 
   <td>Examples</td> 
   <td>HashMap,Vector,ArrayList,HashSet</td> 
   <td><br> CopyOnWriteArrayList,<br> ConcurrentHashMap</td> 
  </tr> 
 </tbody> 
</table>