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

1.什么是同步修改？

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

2.什么是 fail-fast 机制?

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

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

（1）单线程环境

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

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

（2）多线程环境

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

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

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

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

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

[java] view plain copy

 

 

1. private class Itr implements Iterator<E> {  
2.         int cursor;  
3.         int lastRet = -1;  
4.         int expectedModCount = ArrayList.this.modCount;  
5.   
6.         public boolean hasNext() {  
7.             return (this.cursor != ArrayList.this.size);  
8.         }  
9.   
10.         public E next() {  
11.             checkForComodification();  
12.             /** 省略此处代码 */  
13.         }  
14.   
15.         public void remove() {  
16.             if (this.lastRet < 0)  
17.                 throw new IllegalStateException();  
18.             checkForComodification();  
19.             /** 省略此处代码 */  
20.         }  
21.   
22.         final void checkForComodification() {  
23.             if (ArrayList.this.modCount == this.expectedModCount)  
24.                 return;  
25.             throw new ConcurrentModificationException();  
26.         }  
27.     }  

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

4. fail-safe机制

fail-safe任何对集合结构的修改都会在一个复制的集合上进行修改，因此不会抛出ConcurrentModificationException

fail-safe机制有两个问题

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

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

5 fail-fast 和 fail-safe的例子

[java] view plain copy

 

 

1. import java.util.HashMap;  
2. import java.util.Iterator;  
3. import java.util.Map;  
4.   
5. public class FailFastExample  
6. {  
7.       
8.       
9.     public static void main(String[] args)  
10.     {  
11.         Map<String,String> premiumPhone = new HashMap<String,String>();  
12.         premiumPhone.put("Apple", "iPhone");  
13.         premiumPhone.put("HTC", "HTC one");  
14.         premiumPhone.put("Samsung","S5");  
15.           
16.         Iterator iterator = premiumPhone.keySet().iterator();  
17.           
18.         while (iterator.hasNext())  
19.         {  
20.             System.out.println(premiumPhone.get(iterator.next()));  
21.             premiumPhone.put("Sony", "Xperia Z");  
22.         }  
23.           
24.     }  
25.       
26. }  

输出

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)

[java] view plain copy

 

 

1. import java.util.concurrent.ConcurrentHashMap;  
2. import java.util.Iterator;  
3.   
4.   
5. public class FailSafeExample  
6. {  
7.       
8.       
9.     public static void main(String[] args)  
10.     {  
11.         ConcurrentHashMap<String,String> premiumPhone =   
12.                                new ConcurrentHashMap<String,String>();  
13.         premiumPhone.put("Apple", "iPhone");  
14.         premiumPhone.put("HTC", "HTC one");  
15.         premiumPhone.put("Samsung","S5");  
16.           
17.         Iterator iterator = premiumPhone.keySet().iterator();  
18.           
19.         while (iterator.hasNext())  
20.         {  
21.             System.out.println(premiumPhone.get(iterator.next()));  
22.             premiumPhone.put("Sony", "Xperia Z");  
23.         }  
24.           
25.     }  
26.       
27. }  

输出

S5
HTC one
iPhone

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

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