Java集合框架(13): fail-fast

发表于   |   分类于

简介

fail-fast机制是java集合框架中的一种错误机制。当多个线程对同一个集合的结构进行操作时，可能会产生fail-fast，出现java.util.ConcurrentModificationException。

解决办法

fail-fast机制，是一种错误检测机制，只能被用来检测错误，因为JDK并不保证fail-fast机制一定发生。

  1. 方法一：在多线程环境下，应该使用“java.util.concurrent”包下的类去取代“java.util”包下的类。
  2. 方法二：在遍历过程中，所有涉及改变modCount值得地方全部加上synchronized或直接使用Collections.synchronizedList（但是容器结构的更改操作造成的同步锁，可能会阻塞遍历操作，不推荐）。

ArrayList和CopyOnWriteArrayList

这里采用ArrayList的fail-fast机制和CopyOnWriteArrayList来解决这个问题。

ArrayList

ArrayList的Iterator会采用fail-fast机制抛出异常ConcurrentModificationException。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
private class Itr implements Iterator<E> {
    ...
    // 容器的结构修改次数
    // 如果遍历时不相等，则抛出ConcurrentModificationException异常，产生fail-fast事件
    int expectedModCount = modCount;
    ...
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

CopyOnWriteArrayList

CopyOnWriteArrayList的对容器结构的更改方法（add、remove、clear等，以add方法为例），都是对原底层结构array进行复制后，再在复制的数组上进行更改操作，这样就不会影响它的迭代器COWIterator中的array了。

结构更改操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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();
    }
}

迭代器

CopyOnWriteArrayList并不会进行fail-fast机制检测。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
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;
    }
    /**
     * Not supported. Always throws UnsupportedOperationException.
     * @throws UnsupportedOperationException always; {@code remove}
     *         is not supported by this iterator.
     */
    public void remove() {
        throw new UnsupportedOperationException();
    }
    /**
     * Not supported. Always throws UnsupportedOperationException.
     * @throws UnsupportedOperationException always; {@code set}
     *         is not supported by this iterator.
     */
    public void set(E e) {
        throw new UnsupportedOperationException();
    }
    /**
     * Not supported. Always throws UnsupportedOperationException.
     * @throws UnsupportedOperationException always; {@code add}
     *         is not supported by this iterator.
     */
    public void add(E e) {
        throw new UnsupportedOperationException();
    }
}