Java - Java集合中的快速失败Fail Fast 机制

---

什么是 fail-fast

https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html

fail-fast 机制是Java集合(Collection)中的一种错误机制。

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

举个例子：

在多线程环境下，线程1正在对集合进行遍历，此时线程2对集合进行修改 ， 很容易抛出Concurrent Modification Exception 。

当然了，在单线程的情况下，遍历时对集合进行修改也会抛出Concurrent Modification Exception

此类的返回的迭代器iterator和 listIterator方法是快速失败的：如果列表在任何时间后，迭代器创建结构修饰，以任何方式除非通过迭代器自身 remove或 add方法，迭代器都将抛出 Concurrent Modification Exception。

因此，面对并发修改，迭代器快速而干净地失败，而不是冒着在未来不确定的时间出现任意、非确定性行为的风险。

---

源码解读

Itr

在遍历的时候对集合修改会发生fail-fast，遍历集合------> 迭代器

/**
     * 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();
        }
    }

看到了吧， checkForComodification

 final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }

在modCount != expectedModCount的时候抛出了ConcurrentModificationException，

而在next方法中上来就是调用checkForComodification，所以遍历集合才会可能抛出并发修改异常。

那接下来就研究 modCount 和 expectedModCount 什么时候会不相等就行了呗。

• 在创建一个迭代器后，expectedModCount的初始值就是modCount了，

• 对集合修改会改变modCount，

• expectedModCount只会在迭代器的remove方法中被修改为modCount

这都是 中的内容，除了modCount 。 modCount 是ArrayList的常量，默认值 为0

---

为什么对集合的结构进行修改会发生并发修改异常-源码分析

那我们说，在用迭代器遍历一个集合对象时，如果遍历过程中对集合对象的结构进行了修改（增加、删除），则会抛出Concurrent Modification Exception 【并发修改异常】。

修改方法之 remove

modCount++ ， 后面modCount会和expectedModCount不相等，进而抛出并发修改异常。

---

修改方法之 add

ensureCapacityInternal方法里对modCount++操作， 改变了modCount的值，所以调用

那set方法会触发 fast fail吗？

答案是不会。

set没有对modCount++，所以对集合的某个元素进行修改并不会fail-fast

---

案例分享

【案例一】

List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
Iterator<String> iter = list.iterator();
while (iter.hasNext()) {
    String tmp = iter.next();
    System.out.println(tmp);
    if (tmp.equals("1")) {
        list.remove("1");
    }
}

 1
Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:911)
	at java.util.ArrayList$Itr.next(ArrayList.java:861)
	at com.artisan.fastfail.FastFailTest.main(FastFailTest.java:25)

调用了 list# remove方法

---

【案例二】

List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
Iterator<String> iter = list.iterator();
while (iter.hasNext()) {
    String tmp = iter.next();
    System.out.println(tmp);
    if (tmp.equals("3")) {
        list.remove("3");
    }
}

1
2
3

 

调用了 list# remove方法 , 居然没有抛出并发修改异常？？？？

remove倒数第二个元素，然而这时就没有抛出异常了 。 再分析分析吧

cursor是下一个要返回的变量的下标

lastRet是上一个返回过的变量的下标

hasNext方法告诉我们只有在下一个变量的下标不等于size的时候会告诉我们集合还有下一个元素。

但是在remove的时候，size- -了，那么删除“3”这个元素后，size变为3，而此时cursor也是3，那么再走到hasNext时，就发现cursor和size相等了，那么就会退出遍历，“4”压根就不会被遍历到。

所以没有抛出异常，因为remove后就退出了，还没来得及走到next方法呢~

---

【案例三】

List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
Iterator<String> iter = list.iterator();
while (iter.hasNext()) {
    String tmp = iter.next();
    System.out.println(tmp);
    if (tmp.equals("4")) {
        list.remove("4");
    }
}

1
2
3
4
Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:911)
	at java.util.ArrayList$Itr.next(ArrayList.java:861)
	at com.artisan.fastfail.FastFailTest.main(FastFailTest.java:25)

接上个案例

那 删除“4”，也就是最后一个元素，按理说删了最后一个元素不就退出了吗？走不到下一次的next方法呀？

其实是不对的，删完“4”并没有就直接退出 ！ remove后size变成了3，但此时cursor是4，那么走到hasNext时，发现4!=3，就会再次进入循环，那么结果…走到了next方法，抛出了异常。。。

---

【案例四】

List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
for (String i : list) {
    if ("1".equals(i)) {
        list.remove("1");
    }
}

Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:911)
	at java.util.ArrayList$Itr.next(ArrayList.java:861)
	at com.artisan.fastfail.FastFailTest.main(FastFailTest.java:22)

用增强for循环遍历的，反编译class , 和用迭代器实质是一样的 。

---

【案例五】

List<String> list = Arrays.asList("1", "2", "3", "4");
for (String i : list) {
    if ("1".equals(i)) {
        list.remove("1");
    }
}

Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.AbstractList.remove(AbstractList.java:161)
	at java.util.AbstractList$Itr.remove(AbstractList.java:374)
	at java.util.AbstractCollection.remove(AbstractCollection.java:293)
	at com.artisan.fastfail.FastFailTest.main(FastFailTest.java:21)

用了Array.asList()方法生成的集合，抛出的是UnsupportedOperationException，发现asList生成的ArrayList是个静态内部类，并非java.util.ArrayList， 并没有这些方法。

所以不能对asList生成的ArrayList进行增删改

Java开发规范01 - 集合篇_Arrays.asList 坑

---

【案例六】

    List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        Iterator<String> iter = list.iterator();
        while (iter.hasNext()) {
            String tmp = iter.next();
            System.out.println(tmp);
            if (tmp.equals("1")) {
                iter.remove();
            }
        }

1
2
3
4

---

【案例七】

```java
// 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");
		}
	}
}

India
Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.HashMap$HashIterator.nextNode(HashMap.java:1442)
    at java.util.HashMap$KeyIterator.next(HashMap.java:1466)
    at FailFastExample.main(FailFastExample.java:18)

// 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);
			}
		}
	}
}

[1, 3, 4, 5]
Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
    at java.util.ArrayList$Itr.next(ArrayList.java:851)
    at FailFastExample.main(FailFastExample.java:28)

---

---

阿里巴巴Java开发手册中的规定

---

如何避免fail-fast抛异常

1. 如果非要在遍历的时候修改集合，那么建议用迭代器的remove等方法，而不是用集合的remove等方法
2. 并发的环境，那还要对Iterator对象加锁, 也可以直接使用Collections.synchronizedList
3. CopyOnWriteArrayList（采用fail-safe）