快速失败(fail-fast)和安全失败(fail-safe)

最新推荐文章于 2025-05-24 13:03:16 发布

原创最新推荐文章于 2025-05-24 13:03:16 发布 · 220 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#集合

Java 专栏收录该内容

27 篇文章

订阅专栏

本文深入探讨了Java集合框架中的快速失败(fail-fast)和安全失败(fail-safe)机制，解析了两种机制的工作原理，以及如何在多线程环境中避免快速失败事件的发生。文章详细分析了快速失败机制的实现方式，包括modCount变量的作用和检查并发修改的策略。

快速失败(fail-fast)和安全失败(fail-safe)

1.fail-fast和fail-safe比较

Iterator的安全失败是基于对底层集合做拷贝，因此，它不受源集合上修改的影响。

java.util包下面的所有的集合类都是快速失败的，而java.util.concurrent包下面的所有的类都是安全失败的。快速失败的迭代器会抛出ConcurrentModificationException异常，而安全失败的迭代器永远不会抛出这样的异常。

2.如何解决fail-fast机制

出现fail-fast事件
- 当多个线程对同一个集合进行操作的时候，某线程访问集合的过程中，该集合的内容被其他线程所改变(即其它线程通过add、remove、clear等方法，改变了modCount的值)；这时，就会抛出ConcurrentModificationException异常，产生fail-fast事件。（迭代集合时候修改了集合）

fail-fast机制，是一种错误检测机制。它只能被用来检测错误，因为JDK并不保证fail-fast机制一定会发生**。**若在多线程环境下使用fail-fast机制的集合，建议使用“java.util.concurrent包下的类”去取代“java.util包下的类”。

3. fail-fast原理

若 “modCount 不等于 expectedModCount”，则抛出ConcurrentModificationException异常，产生fail-fast事件

源码分析

 public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
      ...
      // AbstractList中唯一的属性
      // 用来记录List修改的次数：每修改一次(添加/删除等操作)，将modCount+1
      protected transient int modCount = 0;
    
     ...
         
        private class Itr implements Iterator<E> {      
                int cursor = 0;
                int lastRet = -1;

              // modCount
                int expectedModCount = modCount;

                public boolean hasNext() {
                    return cursor != size();
                }

                public E next() {
                    checkForComodification();
                    try {
                        int i = cursor;
                        E next = get(i);
                        lastRet = i;
                        cursor = i + 1;
                        return next;
                    } catch (IndexOutOfBoundsException e) {
                        checkForComodification();
                        throw new NoSuchElementException();
                    }
                }

                public void remove() {
                    if (lastRet < 0)
                        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() {
                   //以后每次遍历List中的元素的时候，都会比较expectedModCount和modCount是否相等；
                   // 若不相等，则抛出ConcurrentModificationException异常，产生fail-fast事件。
                    if (modCount != expectedModCount)
                        throw new ConcurrentModificationException();
                }
            }
     
        ...
 }