fail-fast

作者 fan2012huan

文章出处 https://blog.youkuaiyun.com/fan2012huan/article/details/51076970

        快速报错,是指当有其他线程对一个容器(如ArrayList,HashMap)进行了结构性修改,另外一个线程在使用iterator进行迭代该容器,那么这个迭代线程会抛出并发修改的异常ConcurrentModificationException。 

        所谓结构性修改,是对原有容器的size造成影响的操作,如remove、add、clear操作等。

示例代码(一)

 public static void main(String[] args) {
        //这会报不支持的操作异常,UnsupportedOperationException
        //因为,Arrays.assList的底层实现是使用数组实现的,而数组不支持remove操作。
        String string = "a b c d e";
        List<String> stringList = Arrays.asList(string.split(" "));
        Iterator<String> iterator = stringList.iterator();
        while (iterator.hasNext()) {
            if(iterator.next().equals("c")) {
                stringList.remove("c");
            }
        }
    }

2.执行结果 


3.解析 

        原因在于List<String> stringList = Arrays.asList(string.split(" ")); 这句话。ArrayList.asList返回的List是固定大小的List,也就是说不可以对其进行add、remove操作。 

        ArrayList.asList的源码实现如下:

  //Returns a fixed-size list backed by the specified array.
    @SafeVarargs
    @SuppressWarnings("varargs")
    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

    //该ArrayList类不是java.util包中的内容,而是Arrays类的内部类。
    private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable
    {
        private static final long serialVersionUID = -2764017481108945198L;
        private final E[] a;

        ArrayList(E[] array) {
            a = Objects.requireNonNull(array);
        }

        /*省略此处代码*/

    }

        从上面代码的注释中可以看到是 “返回的是固定大小的List”。

        从源码实现上可以看到,private final E[] a; ,内部类ArrayList中的成员变量a,是final的。

示例代码(二)

    注意,这个示例代码中的ArrayList不是上一个示例中出现的内部类,而是java.util.ArrayList。 

    1.代码

 public static void main(String[] args) {
        String string = "a b c d e";
        List<String> stringList1 = Arrays.asList(string.split(" "));
        //这个会得到  并发修改异常  ConcurrentModificationException
        List<String> stringList = new ArrayList<String>(stringList1);
        System.out.println(stringList);

        Iterator<String> iterator = stringList.iterator();
        while (iterator.hasNext()) {
            if(iterator.next().equals("c")) {
                stringList.remove("c");
            }
        }
    }
2.执行结果 

3.解析 

        从抛异常的报告上对应的代码是if(iterator.next().equals("c")) { 这一行。从调用栈来看,是在java.util.ArrayList的内部类Itr的next方法在调用checkForComodification方法时抛的异常。 

        来看看java.util.ArrayList的相关源码实现。

private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }

        /**省略此处代码**/

    }

其中的modCount是ArrayList的一个属性。

 /*
     * The number of times this list has been <i>structurally modified</i>.
     * Structural modifications are those that change the size of the
     * list, or otherwise perturb it in such a fashion that iterations in
     * progress may yield incorrect results.
     * /
    protected transient int modCount = 0;

        源码给的注释可以看到,modCount用来表示list被结构性修改的次数。所谓结构性修改是指,改变了list的size,或者在迭代过程中产生了不正确的结果。 

        内部类在被示例化时会将modCount赋值给expectedModCount。 

        内部类的实例化发生在ArrayList的iterator被调用的时候,即Iterator<String> iterator = stringList.iterator(); 这句话执行时初始化的。看看ArrayList#iterator的实现:
  public Iterator<E> iterator() {
        return new Itr();
    }

        从next方法的实现上可以看到,首先就会判断expectedModCount与modCount是否相等,如果不等就会抛ConcurrentModificationException异常。不相等说明其他线程修改了modCount。当然,在这个例子中只有main线程,也出现了这种情况。因为,在迭代到”c”时,stringList.remove("c"); 执行了remove操作,对list造成了结构性修改,改变了list的size,modCount的值会加1。这样当迭代到”d”时,发现expectedModCount与modCount不等了,因此抛异常了。

代码示例(三)

1.代码:

public static void main(String[] args) {
        String string = "a b c d e";
        List<String> stringList1 = Arrays.asList(string.split(" "));
        List<String> stringList = new ArrayList<String>(stringList1);
        System.out.println(stringList);

        Iterator<String> iterator = stringList.iterator();
        while (iterator.hasNext()) {
            if(iterator.next().equals("c")) {
                //这里跟上例不同,上例为stringList.remove("c");
                iterator.remove();
            }
        }
        System.out.println(stringList);
    }
2.执行结果 

这里写图片描述

3.解析 
可以看到,使用iterator.remove()没有抛异常,而且成功修改stringList的内容。 

来看看ArrayList#Itr#remove方法的实现。

private class Itr implements Iterator<E> {

        /**省略此处代码**/

        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();
            }
        }
        /**省略此处代码**/    
    }
        从上面代码可以看到,首先也判断了expectedModCount与modCount是否相等,但是这时还没有执行remove操作,因此不会抛异常。在执行了ArrayList.this.remove(lastRet); 之后,有一个关键的一行expectedModCount = modCount; 更新了expectedModCount的值。 

        下面来看看ArrayList#remove()方法的实现。

public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index, numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

首先执行了modCount++; , 之后在本地修改elementData的内容,最后elementData[--size] = null; 便于垃圾回收。


<think>嗯,用户想了解Java中fail-safe和fail-fast迭代器的区别以及它们的工作原理。我需要先回忆一下这两个概念。根据之前的引用内容,Fail-FastFail-Safe主要与集合的并发修改有关。 首先,Fail-Fast迭代器可能在检测到并发修改时立即抛出异常。比如,当使用ArrayList的迭代器时,如果在遍历过程中集合被修改,就会抛出ConcurrentModificationException。引用[1]提到过Fail-Fast的机制,可能在修改次数(modCount)和期望值不一致时触发。那它的实现原理应该是通过一个计数器来记录修改次数,迭代器保存这个值的副本,每次操作前检查是否一致。 然后是Fail-Safe迭代器,比如在并发包里的CopyOnWriteArrayList。引用[2]指出,fail-safe的迭代器在遍历时不会抛出异常,因为它们基于数据快照工作。也就是说,迭代器创建时会复制原集合的数据,之后即使原集合被修改,迭代器看到的还是旧的数据。但这样可能会读到过期的数据,不过避免了异常。 需要区分两者的应用场景。Fail-Fast适用于单线程环境,快速失败有助于尽早发现错误,而Fail-Safe适合多线程并发,避免迭代过程中因修改而中断。引用[3]中可能提到,Fail-Safe的缺点包括内存开销和弱一致性,因为复制数据需要额外空间,且无法保证实时性。 用户可能还想知道具体例子,比如哪些集合属于哪种类型。比如,ArrayList的迭代器是Fail-Fast的,而ConcurrentHashMap的迭代器是Fail-Safe的。另外,Fail-Safe的实现方式除了复制数据,可能还有其他的机制,比如使用并发控制来允许修改同时不影响迭代。 可能还要比较两者的优缺点,Fail-Fast的响应速度快但线程不安全,Fail-Safe更安全但资源消耗大。需要确保解释清晰,让用户明白在何种情况下选择哪种机制。</think>### Java中Fail-Safe与Fail-Fast迭代器的区别及原理 #### 1. **Fail-Fast(快速失败)迭代器** - **核心机制**:在遍历集合时,如果检测到集合内容被修改(例如增删元素),**立即抛出$ConcurrentModificationException$**,终止遍历[^1][^3]。 - **实现原理**: - 集合内部维护一个`modCount`(修改计数器),每次修改操作(如`add`、`remove`)会递增该值。 - 迭代器初始化时记录当前的`modCount`,每次遍历时检查是否与当前`modCount`一致。若不一致则触发异常。 - **特点**: - 适用于单线程环境,强调“快速暴露错误”。 - 无法保证多线程并发修改下的安全性。 - **示例集合**:`ArrayList`、`HashMap`的默认迭代器。 #### 2. **Fail-Safe(安全失败)迭代器** - **核心机制**:允许在遍历过程中修改集合,**不会抛出异常**,但可能读取到过时数据(弱一致性)[^2]。 - **实现原理**: - 基于集合的**数据快照**:迭代器创建时复制原集合的数据(如`CopyOnWriteArrayList`)或通过并发控制(如`ConcurrentHashMap`的分段锁)[^2]。 - 遍历操作基于快照进行,与原集合的实际修改无关。 - **特点**: - 适用于多线程并发场景,避免遍历中断。 - 可能消耗更多内存(复制数据)且数据非实时。 - **示例集合**:`CopyOnWriteArrayList`、`ConcurrentHashMap`的迭代器。 --- #### **对比表格** | 特性 | Fail-Fast迭代器 | Fail-Safe迭代器 | |---------------------|--------------------------------|--------------------------------| | **异常触发** | 检测到修改立即抛出异常 | 不抛出异常 | | **数据一致性** | 强一致性(遍历时锁定原集合) | 弱一致性(基于快照或并发控制) | | **内存消耗** | 低 | 可能较高(需复制数据) | | **适用场景** | 单线程环境 | 多线程并发环境 | | **典型集合** | `ArrayList`, `HashMap` | `CopyOnWriteArrayList`, `ConcurrentHashMap` | --- #### **工作原理示例** 1. **Fail-Fast场景**: ```java List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3)); Iterator<Integer> it = list.iterator(); list.add(4); // 修改原集合 it.next(); // 抛出ConcurrentModificationException ``` 2. **Fail-Safe场景**: ```java List<Integer> list = new CopyOnWriteArrayList<>(Arrays.asList(1, 2, 3)); Iterator<Integer> it = list.iterator(); list.add(4); // 修改原集合 it.forEachRemaining(System.out::print); // 输出1,2,3(不包含新增的4) ``` ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值