声明
特点：基于JDK源码进行分析。
研究费时费力，如需转载或摘要，请显著处注明出处，以尊重劳动研究成果：博客园 - https://www.cnblogs.com/johnnyzen/p/10547179.html，侵权必究，蟹蟹理解。
/** * @IDE: Created by IntelliJ IDEA. * @Author: 千千寰宇 * @Email: 1125418540@qq.com * @Date: 2019/3/17 12:46:34 * @Description: Java SE之Fast-Fail与Fast-Safe的区别[集合与多线程/增强For] */
[1] Fast-Fail事件
特征
① java.util包下面的所有的集合类
+ ArrayList / HashMap / LinkedList / Iterator / Collections / …
②会抛出ConcurrentModificationException异常，一种错误检测机制
③产生条件：其一，当多个线程对Collection下的集合类进行操作时，若其中某一个线程通过iterator去遍历集合时，该集合的内容被其他线程所改变；其二，单线程环境下，如果单次遍历对该包下的集合对象进行多次写操作，则也可能抛出ConcurrentModificationException异常。
④解决办法：通过util.concurrent包下的相应类去处理，则：不会产生fast-fail事件，即fast-safe
案例分析
【测试源码】
public static void arrayList(){
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
for(Object obj : list){
System.out.println(obj);
list.remove(obj); //使用集合对象list删除元素
}
}
【运行结果】
【原因】
//ArrayList的内部数组
transient Object[] elementData;
//ArrayList的iterator()方法
public Iterator<E> iterator() {
return new Itr();
}
//ArrayList的remove()方法
public boolean remove(Object o) {
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index); //关键调用处：修改 modCount++
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);//关键调用处：修改 modCount++
return true;
}
}
return false;
}
//ArrayList的fastRemove()方法
private void fastRemove(int index) {
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//对list对象内部数组的元素进行删除，但会修改modCount值
elementData[--size] = null; // clear to let GC do its work
}
//ArrayList 的私有内部类Itr implements Iterator的next()
private class Itr implements Iterator<E> {
int expectedModCount = modCount;
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();//检查modCount与expectedModCount
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];
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
//对list对象内部数组的元素进行删除，但不会修改modCount值
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;//即 使用ArrayList对象获取的iterator对象的remove方法删除元素时，将设置expectedModCount = modCount ，以确保下一次能通过checkForComodification()
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}//Itr.remove() end
}//Itr end
1.Java.util包下的集合类（如：ArrayList）的迭代器（如：私有内部类Itr）在遍历时直接访问集合中的内容,并且在遍历过程中使用了modCount变量
2.Java.util包下的集合类（如：ArrayList）的集合对象中在被遍历期间如果内容发生变化,就会改变modCount的值（如：ArrayList的remove()）
3.每当集合类（如：ArrayList）对象的迭代器使用 hashNext()/next()遍历下一个元素之前,都会检测modCount变量和expectedmodCount值是否相等
4.如果相等就返回遍历结果,否则抛出异常,终止遍历
（整个分析过程，可参见上述ArrayList中源码）引用于[2]
【另外：关于ArrayList.remove()与其ArrayList.iterator().reomve()的区别？】
上述案例的源码中使用 Collection（ArrayList 的父类） 集合对象list中的 remove（）方法。该方法只能从集合中删除元素，不能把迭代器iterator中的元素也删除了。即：
ArrayList.remove() 删除元素时，修改modCount++ |
ArrayList.Itr.remove() 删除元素时，调用ArrayList.remove()后，立即设置modCount=expectedmodCount， 避免了并发修改异常（ConcurrentModificationException）。 值得注意的是：两方法均是对同一对象的同一动态数组(elementData)进行操作。那么，在多线程环境下，如果多个线程对同一list对象进行操作时，elementData便是实际上的共享互斥资源，则 可能造成数据污染的非线程安全事件。 |
【产生问题】
1.【单线程环境】当使用foreach循环时，欲实现对util包下的集合对象的一边遍历一边增、删集合元素时，该怎么办？
答：其一，每次遍历进行单次写操作，通过集合对象的迭代器iterator对应增、删元素(Itr.remove())的方法，线程安全。
//demo 不会抛并发修改异常
Iterator it = list.iterator();
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
if(obj.equals(1)){
it.remove();//使用迭代器的remove()方法
}
}
其二，每次遍历进行多次写操作，不一定线程安全。原因是：并发修改异常触发时，必须满足checkForComodification()方法的modCount == expectedmodCount的成立。那么，如果集合发生变化时修改modCount值, 刚好有设置为了expectedmodCount值, 则异常不会抛出。
比如：先删除一条数据,再添加一条数据。
//此时，不会抛并发修改异常
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
for(Object obj : list){
System.out.println(obj);
if(obj == new Integer(2)){ //使用equals()也会抛并发修改异常
list.remove(obj);
list.add(2);
}
}
2.【多线程环境】当多个线程同时对util包下的同一集合对象进行写操作时，是否线程安全？
答：不能依赖于ConcurrentModificationException异常是否抛出，而进行并发操作的编程, 该异常只检测并发修改的BUG。
【结论】
java.util包下的集合类都是快速失败(fail-fast)机制的, 不能在多线程下发生并发修改，在单线程下，也不推荐迭代过程中修改该集合类对象的元素值。引用于[2]
[2] Fast-Safe事件
①java.util.concurrent包下面的所有的类
+ BlockingDeque / LinkedBlockingDeque / SynchronousQueue
+ ConcurrentHashMap / ConcurrentLinkedQueue / CopyOnWriteArrayList
+ …
②不会抛出并发修改异常；采用安全失败机制的集合容器，在遍历时不是直接在集合内容上访问的，而是先复制原有集合内容，在拷贝的集合上进行遍历。
③结论：java.util.concurrent包下的容器都是安全失败的,可以在多线程下并发使用,并发修改。 引用于[2]
④原理：由于迭代时是对原集合的拷贝的值进行遍历,所以在遍历过程中对原集合所作的修改并不能被迭代器检测到,所以不会出发ConcurrentModificationExceptio
⑤缺陷：基于拷贝内容的优点是避免了ConcurrentModificationException,但同样地, 迭代器并不能访问到修改后的内容 (简单来说就是, 迭代器遍历的是开始遍历那一刻拿到的集合拷贝,在遍历期间原集合发生的修改迭代器是不知道的) 引用于[2]
[3] 补充：增强for
特征
①增强型for | For/in | Foreach循环语法：for(ElementType element:arrayName){}
②不支持遍历时修改。详见上述fast-fail中关于“每次遍历单/多次修改”。
③对遍历的集合需要做null判断，不然可能引发空指针异常。
④增强for循环的内部:
遍历数组，foreach 循环实际上还是用的普通的 for 循环 引用[1]
遍历集合，foreach 循环实际上是用的 iterator 迭代器迭代 引用[1]
备注：始于JDK1.5
案例分析
【测试源码】
//实验
public class Foreach {
public static void foreach(){
int [] array = {1,2,3};
for(int i : array){
System.out.println(i);
}
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
for(Object obj : list){
System.out.println(obj);
}
}
}
【反编译结果】javap -c sourceFile
[4] 参考文献
备注：该大V博文关于fast-fail与fast-safe的探究，认为是增强for循环基于多线程是错误的，毫无依据，JDK源码中也并未体现。
[2]【荐】fail-fast和fail-safe的介绍和区别
[4]【荐】Concurrent下的线程安全集合