一、Fail-Fast、Fail-Safe系统简介
Fail-Fast系统好，还是Fail-Safe系统好，这始终是系统设计领域中讨论最多的主题。
- Fail-Fast系统
如果系统在发生错误时立即关闭，则称其为Fail-Fast。 这些系统不会带着错误继续执行。 当系统发生故障时，它们会立即停止运行。 Fail-Fast系统中的错误会立即暴露出来
- Fail-Safe系统
Fail-Safe系统发生故障，它们也不会停止运行，它们通过隐藏错误来继续操作。 它们不会立即暴露错误，它们会带着错误继续执行。
二、Java迭代器中的Fail-Fast、Fail-Safe
java中的迭代器为我们提供了遍历Collection对象的工具。集合返回的迭代器本质上是Fail-Fast或Fail-Safe的。 如果在迭代时修改了集合，则Fail-Fast迭代器会立即抛出ConcurrentModificationException。 如果在迭代迭代时修改了集合，则Fail-Safe迭代器不会抛出任何异常。因为，它们在集合的克隆上运行，而不是在实际集合上运行。
- Fail-Fast迭代器
大多数集合类型返回的Fail-Fast迭代器在迭代它时不允许对集合进行任何结构修改。（结构修改意味着添加，删除或更新集合中的元素）如果在对集合进行迭代时对结构进行了结构修改，则抛出ConcurrentModificationException。但是，如果通过迭代器自己的方法（如remove（））修改集合，它们不会抛出任何异常。
- Fail-Fast原理（以ArrayList为例）
产生Fail-Fast事件，是通过抛出ConcurrentModificationException异常来触发的。那么ArrayList是如何抛出该异常的呢？
我们知道，ConcurrentModificationException是在操作Iterator时抛出的异常。我们先看看Iterator的源码。ArrayList的Iterator是在父类AbstractList.java中实现的。代码如下：
package java.util;
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
...
// AbstractList中唯一的属性
// 用来记录List修改的次数：每修改一次(添加/删除等操作)，将modCount+1
protected transient int modCount = 0;
// 返回List对应迭代器。实际上，是返回Itr对象。
public Iterator<E> iterator() {
return new Itr();
}
// Itr是Iterator(迭代器)的实现类
private class Itr implements Iterator<E> {
int cursor = 0;
int lastRet = -1;
// 修改数的记录值。
// 每次新建Itr()对象时，都会保存新建该对象时对应的modCount；
// 以后每次遍历List中的元素的时候，都会比较expectedModCount和modCount是否相等；
// 若不相等，则抛出ConcurrentModificationException异常，产生fail-fast事件。
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size();
}
public E next() {
// 获取下一个元素之前，都会判断“新建Itr对象时保存的modCount”和“当前的modCount”是否相等；
// 若不相等，则抛出ConcurrentModificationException异常，产生fail-fast事件。
checkForComodification();
try {
E next = get(cursor);
lastRet = cursor++;
return next;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
public void remove() {
if (lastRet == -1)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.remove(lastRet);
if (lastRet < cursor)
cursor--;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
...
}
从中，我们可以发现在调用 next() 和 remove()时，都会执行 checkForComodification()。若 “modCount 不等于 expectedModCount”，则抛出ConcurrentModificationException异常，产生fail-fast事件。
要搞明白 fail-fast机制，我们就要需要理解什么时候“modCount不等于expectedModCount”！从Itr类中，我们知道expectedModCount在创建Itr对象时，被赋值为modCount。通过Itr，我们知道：expectedModCount不可能被修改为不等于modCount。所以，需要考证的就是modCount何时会被修改。
接下来，我们查看ArrayList的源码，来看看modCount是如何被修改的。
package java.util;
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
...
// list中容量变化时，对应的同步函数
public void ensureCapacity(int minCapacity) {
modCount++;
int oldCapacity = elementData.length;
if (minCapacity > oldCapacity) {
Object oldData[] = elementData;
int newCapacity = (oldCapacity * 3)/2 + 1;
if (newCapacity < minCapacity)
newCapacity = minCapacity;
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
}
// 添加元素到队列最后
public boolean add(E e) {
// 修改modCount
ensureCapacity(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
// 添加元素到指定的位置
public void add(int index, E element) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: "+size);
// 修改modCount
ensureCapacity(size+1); // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
// 添加集合
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
// 修改modCount
ensureCapacity(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
// 删除指定位置的元素
public E remove(int index) {
RangeCheck(index);
// 修改modCount
modCount++;
E oldValue = (E) 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;
}
// 快速删除指定位置的元素
private void fastRemove(int index) {
// 修改modCount
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // Let gc do its work
}
// 清空集合
public void clear() {
// 修改modCount
modCount++;
// Let gc do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
...
}
从中，我们发现：无论是add()、remove()，还是clear()，只要涉及到修改集合中的元素个数时，都会改变modCount的值。
接下来，我们再系统的梳理一下fail-fast是怎么产生的。步骤如下：
- 新建了一个ArrayList，名称为arrayList。
- 向arrayList中添加内容。
- 新建一个“线程a”，并在“线程a”中通过Iterator反复的读取arrayList的值。
- 新建一个“线程b”，在“线程b”中删除arrayList中的一个“节点A”。
- 这时，就会产生有趣的事件了。在某一时刻，“线程a”创建了arrayList的Iterator。此时“节点A”仍然存在于arrayList中，创建arrayList时，expectedModCount = modCount(假设它们此时的值为N)。在“线程a”在遍历arrayList过程中的某一时刻，“线程b”执行了，并且“线程b”删除了arrayList中的“节点A”。“线程b”执行remove()进行删除操作时，在remove()中执行了“modCount++”，此时modCount变成了N+1！“线程a”接着遍历，当它执行到next()函数时，调用checkForComodification()比较“expectedModCount”和“modCount”的大小；而“expectedModCount=N”，“modCount=N+1”,这样，便抛出ConcurrentModificationException异常，产生fail-fast事件。
至此，我们就完全了解了fail-fast是如何产生的！
- Fail-Safe迭代器
如果在迭代时修改了集合，则Fail-Safe迭代器不会抛出任何异常。因为，他们迭代集合的克隆而不是实际的集合。 因此，对这些迭代器不会注意到对实际集合所做的任何结构修改。但是，这些迭代器有一些缺点：
- 1）并不总能保证您在迭代时获得最新数据。因为迭代器中创建的对集合的任何修改都不会在迭代器中更新；
- 2）在时间和内存方面创建集合副本会产生额外的开销。
