快速失败机制--fail-fast
fail-fast 机制是Java集合(Collection)中的一种错误机制。当多个线程对同一个集合的内容进行操作时，就可能会产生fail-fast(快速失败)事件。例如：当某一个线程A通过iterator去遍历某集合的过程中，若该集合的内容被其他线程所改变了；那么线程A访问集合时，就会抛出ConcurrentModificationException异常，产生fail-fast事件。
迭代器的快速失败行为无法得到保证，它不能保证一定会出现该错误，但是快速失败操作会尽最大努力抛出ConcurrentModificationException异常。
注意：上面所说的是在多线程环境下会发生fail-fast事件，但是单线程条件下如果违反了规则也是会产生fail-fast事件的
在文档中有这么一段话：编写的程序依赖于快速失败机制产生的异常是不对的，迭代器的快速检测机制仅仅用于检测错误。
分别用两段程序测试快速失败机制产生的原因：
单线程环境：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* Created with IDEA
*
* @author DuzhenTong
* @Date 2018/3/18
* @Time 17:34
*/
public class FailFast {
public static void main(String[] args) {
List list = new ArrayList();
for (int i = 0; i < 10; i++) {
list.add(i);
}
iterator(list);
}
public static void iterator(List list) {
Iterator it = list.iterator();
int index = 0;
while (it.hasNext()) {
if (index == 6) {
list.remove(index);
}
index++;
System.out.println(it.next());
}
}
}
输出结果：
0
1
2
3
4
5
Exception in thread "main" java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:819)
at java.util.ArrayList$Itr.next(ArrayList.java:791)
at FailFast.iterator(FailFast.java:29)
at FailFast.main(FailFast.java:18)
多线程环境：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* Created with IDEA
*
* @author DuzhenTong
* @Date 2018/3/18
* @Time 17:59
*/
public class FailFast1 {
public static List list = new ArrayList();
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
list.add(i);
}
new ThreadA().start();
new ThreadB().start();
}
public static class ThreadA extends Thread {
@Override
public void run() {
Iterator it = list.iterator();
while (it.hasNext()) {
System.out.println("集合遍历中……："+it.next());
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static class ThreadB extends Thread {
@Override
public void run() {
int index = 0;
while (index != 10) {
System.out.println("线程等待中……："+index);
if (index == 3) {
list.remove(index);
}
index++;
}
}
}
}
输出结果：
线程等待中……：0
集合遍历中……：0
线程等待中……：1
线程等待中……：2
线程等待中……：3
线程等待中……：4
线程等待中……：5
线程等待中……：6
线程等待中……：7
线程等待中……：8
线程等待中……：9
Exception in thread "Thread-0" java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:819)
at java.util.ArrayList$Itr.next(ArrayList.java:791)
at FailFast1$ThreadA.run(FailFast1.java:28)
上面的程序已经说明了为什么会发生fail-fast事件（快速失败），在多线程条件下，一个线程正在遍历集合中的元素，这时候另一个线程更改了集合的结构，程序才会抛出ConcurrentModificationException，在单线程条件下也是在遍历的时候，这时候更改集合的结构，程序就会抛出ConcurrentModificationException。
要具体知道为什么会出现fail-fast，就要分析源码，fail-fast出现是在遍历集合的时候出现的，也就是对集合进行迭代的时候，对集合进行迭代的时候都是操作迭代器，集合中的内部类：（ArrayList源码）
private class Itr implements Iterator<E> {
int cursor;
int lastRet = -1;
int expectedModCount = modCount;//---------------------1
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
//………此处代码省略…………
}
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();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
上面的代码中我们可以看到抛出ConcurrentModificationException异常，上面的next(),remove()都会调用checkForComodification()方法检查两个变量的值是否相等，不相等就会抛出异常。在上面程序中的数字1处：
int expectedModCount = modCount;
modCount的值赋值给expectedModCount，知道modCount这个值的含义是什么？为什么会发生改变？原因就会找到了。
源码点进去，发现这个modCount变量并不在ArrayList类中，而在AbstractList中，作为一个成员变量。
protected transient int modCount = 0;
接下来分析源码，看最常用的方法
ArrayList中add方法：
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
调用的ensureCapacityInternal方法：
private void ensureCapacityInternal(int minCapacity) {
modCount++;//modCount自增————————————
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
ArrayList中的remove方法：
public E remove(int index) {
rangeCheck(index);
modCount++;//modCount自增——————————————
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // Let gc do its work
return oldValue;
}
ArrayList中的clear方法：
public void clear() {
modCount++;//modCount自增——————————————
// Let gc do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
分析了源码就知道原因是什么了，凡是涉及到改变了集合的结构（改变元素的个数）的操作（包括增加，移除或者清空等）modCount这个变量都会自增，在获得迭代对象的时候，先把这个modCount变量赋值给expectedModCount，在迭代的时候每次都会检查这个变量是否与expectedModCount一致，因为如果是在集合中添加或者删除元素modCount的值都会发生改变。
解决方法：
- 对于涉及到更改集合中元素个数的操作通通加上synchronized，或者利用Collections.synchronizedList强制他们的操作都是同步的。
- 使用CopyOnWriteArrayList来替换ArrayList
这里在网上看到很多的文章都是这么说的：为什么CopyOnWriteArrayList可以做到不会发生fail-fast？因为CopyOnWriteArrayList所有可变操作（add、set 等等）都是通过对底层数组进行一次新的复制来实现的。
可以分析源码（下面的1，2处）
public boolean add(E e) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();//————————1
int len = elements.length;
Object[] newElements = Arrays.copyOf(elements, len + 1);//————————2
newElements[len] = e;
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}
我的看法：原因不止有CopyOnWriteArrayList的add、set、remove等会改变原数组的方法中，都是先copy一份原来的array，再在copy数组上进行add、set、remove操作，这就才不影响COWIterator那份数组。
为什么没有记录修改次数的值或者说不比较modCount也能做到内存的一致性呢？
在上面的代码1处，调用了getArray()方法，看源码：
final Object[] getArray() {
return array;
}
private volatile transient Object[] array;
因为getArray()返回的array的类型是用volatile修饰的，volatile类型的（强制内存一致性）
具体可以看我的另一篇关于volatile的：volatile关键字解析
