fsilsafe java_Java SE之快速失败(Fast-Fail)与快速安全(Fast-Safe)的区别[集合与多线程/增强For]（彻底详解）...

声明

特点：基于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 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 {

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源码中也并未体现。