一、前言
站在巨人的肩膀上，本系列的Java集合框架文章参考了skywang12345——Java 集合系列，真心讲的很好，可以参考。但是不足的是，时间过于长久了，大佬的文章是基于JDK1.6.0_45，对于现在来说至少都用JDK 8.0以上了，而且JDK 6.0与JDK 8.0中集合框架的改动挺大的，所以本系列的文章是基于JDK_1.8.0_161进行说明的。
二、简介
fail-fast机制是java集合(Collection)中的一种错误机制。当使用foreach或者iterator进行遍历的同时，对ArrayList的数据进行了修改；当多个线程对同一个集合的内容进行操作时，就可能会产生fail-fast事件，就会抛出ConcurrentModificationException异常。
三、fail-fast示例
//使用foreach或者iterator进行遍历情况是一样的，就不举iterator的例子了
public class CollectionClass {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
for(String str : list) {
list.remove("a");
}
}
}
使用多个线程对同一集合进行操作
public class CollectionClass {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
MyThreadOne t1 = new MyThreadOne(list);
MyThreadTwo t2 = new MyThreadTwo(list);
t1.start();
t2.start();
}
private static void showAll(List<String> list) {
Iterator<String> ite = list.iterator();
while (ite.hasNext()) {
System.out.println(ite.next());
}
}
public static class MyThreadOne extends Thread {
List<String> list;
public MyThreadOne(List<String> list) {
this.list = list;
}
@Override
public void run() {
int i = 0;
while (i < 6) {
list.add("i:" + i);
i++;
showAll(list);
}
}
}
public static class MyThreadTwo extends Thread {
List<String> list;
public MyThreadTwo(List<String> list) {
this.list = list;
}
@Override
public void run() {
int i = 0;
while (i < 10) {
list.add("i:" + i);
i++;
showAll(list);
}
}
}
}
以上的两个例子都会造成ConcurrentModificationException异常。
四、fail-fast解决办法
fail-fast机制，是一种错误检测机制。它只能被用来检测错误，因为JDK并不保证fail-fast机制一定会发生。建议使用“java.util.concurrent包下的类”去取代“java.util包下的类”。所以，本例中只需要将ArrayList替换成java.util.concurrent包下对应的类即可。即将
List<String> list = new ArrayList<>();
替换成
List<String> list = new CopyOnWriteArrayList<>();
五、fail-fast原理
产生fail-fast事件，是通过抛出ConcurrentModificationException异常来触发的。那么，ArrayList是如何抛出ConcurrentModificationException异常的呢?根据上一篇文章Java集合框架-ArrayList的源码解析中我们已经说过，在进行iterator迭代的时候，当modCount != expectedModCount时就会抛出throw new ConcurrentModificationException()异常。那什么时候modCount会被修改，上篇文章中说到无论是add()、remove()，还是clear()，只要涉及到修改集合中的元素个数时，都会改变modCount的值。即，当多个线程对同一个集合进行操作的时、或者在同一个线程中在进行迭代遍历时对集合进行操作时，该集合的内容被改变(即其它线程通过add、remove、clear等方法，改变了modCount的值)；这时，就会抛出ConcurrentModificationException异常，产生fail-fast事件。
六、CopyOnWriteArrayList源码解析
上面我们已经说明了产生fail-fast的原因，以及解决fail-fast的方法，即使用java.util.concurrent.CopyOnWriteArrayList类。那么下面我们就来看看CopyOnWriteArrayList类是怎么解决fail-fast问题的。下面给出部分CopyOnWriteArrayList中源码片段。
public class CopyOnWriteArrayList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
......
final transient ReentrantLock lock = new ReentrantLock();
private transient volatile Object[] array;
final Object[] getArray() {
return array;
}
final void setArray(Object[] a) {
array = a;
}
//添加元素
public boolean add(E e) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
//拷贝一份新数组
Object[] newElements = Arrays.copyOf(elements, len + 1);
newElements[len] = e;
//替换原来的数组
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}
//清空集合列表
public void clear() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
//直接替换成一个空数组
setArray(new Object[0]);
} finally {
lock.unlock();
}
}
//删除元素
public E remove(int index) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
E oldValue = get(elements, index);
int numMoved = len - index - 1;
if (numMoved == 0)
//拷贝数组并替换
setArray(Arrays.copyOf(elements, len - 1));
else {
Object[] newElements = new Object[len - 1];
//拷贝数组
System.arraycopy(elements, 0, newElements, 0, index);
System.arraycopy(elements, index + 1, newElements, index, numMoved);
//替换
setArray(newElements);
}
return oldValue;
} finally {
lock.unlock();
}
}
//返回迭代器
public Iterator<E> iterator() {
return new COWIterator<E>(getArray(), 0);
}
static final class COWIterator<E> implements ListIterator<E> {
/** Snapshot of the array */
private final Object[] snapshot;
/** Index of element to be returned by subsequent call to next. */
private int cursor;
private COWIterator(Object[] elements, int initialCursor) {
cursor = initialCursor;
snapshot = elements;
}
public boolean hasNext() {
return cursor < snapshot.length;
}
public boolean hasPrevious() {
return cursor > 0;
}
@SuppressWarnings("unchecked")
public E next() {
if (! hasNext())
throw new NoSuchElementException();
return (E) snapshot[cursor++];
}
@SuppressWarnings("unchecked")
public E previous() {
if (! hasPrevious())
throw new NoSuchElementException();
return (E) snapshot[--cursor];
}
public int nextIndex() {
return cursor;
}
public int previousIndex() {
return cursor-1;
}
public void remove() {
throw new UnsupportedOperationException();
}
public void set(E e) {
throw new UnsupportedOperationException();
}
public void add(E e) {
throw new UnsupportedOperationException();
}
@Override
public void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
Object[] elements = snapshot;
final int size = elements.length;
for (int i = cursor; i < size; i++) {
@SuppressWarnings("unchecked") E e = (E) elements[i];
action.accept(e);
}
cursor = size;
}
}
......
}
从源码中我们可以看出：
- CopyOnWriteArrayList和ArrayList不同，CopyOnWriteArrayList没有继承于AbstractList，它仅仅只是实现了List接口；
- CopyOnWriteArrayList的add、clear、remove操作中加入了锁操作，并且是先拷贝了一份原来的数组，再在拷贝的数组上进行add或remove操作，这就不会影响到原来的数组。
- 在COWIterator类的的各个方法中，没有checkForComodification()方法来检查modCount != expectedModCount，所以也就不会抛出ConcurrentModificationException异常。
