【JavaSE】fail-fast与fail-safe源码分析

淩亂°似流年 2024-03-27 11:34 5阅读 0赞

#### 文章目录 ####

*  1. fail-fast与fail-safe概述
 *  2. fail-fast源码分析
 *  3. fail-safe源码分析
 *  4. 总结

## 1. fail-fast与fail-safe概述 ##

`快速失败(fail-fast)`，快速失败是Java集合的一种错误检测机制。

1.  **出现场景**：线程A在使用迭代器遍历一个集合对象的时候，线程B对集合对象的内存进行了操作（增加、删除、修改），这时候会抛出`Concurrent Modification Exception`
2.  **原理**：就拿`ArrayList`来说，`ArrayList`继承了一个抽象类`AbstractList`，这个抽象了中有一个成员变量`protected transient int modCount = 0;`，这个变量是记录集合被修改的次数的。集合使用迭代器进行遍历的时候，每当迭代器使用`hashNext()/next()`之前，会先检测`modCount`变量是否为`expectedmodCount`值，是的话就遍历；否则抛出异常。
3.  **注意**：这里抛出异常的判断条件为`modCount`变量是否为`expectedmodCount`值，如果集合发生变化时，`modCount`值刚好又设置为了`expectedmodCount`值。**因此，不能依赖于这个异常是否抛出而进行并发操作的编程，这个异常只建议用于检测并发修改的bug。**
4.  场景：`java.util`包下的集合类都是快速失败的，不能在多线程下发生并发修改（迭代过程中被修改），比如`ArrayList`类。

`安全失败（fail—safe）`，采用安全失败的集合容器，在遍历时不是直接在集合内容上访问的，**而是先复制原有集合内容，在拷贝的集合上进行遍历。**

1.  **原理**：由于迭代时是对原集合的拷贝进行遍历，所以在遍历过程中对原集合所作的修改并不能被迭代器检测到，所以不会触发`Concurrent Modification Exception`。
2.  **缺点**：基于拷贝内容的优点是避免了`Concurrent Modification Exception`，但同样地，迭代器并不能访问到修改后的内容，也就是说迭代器遍历的是开始遍历那一刻拿到的集合拷贝，在遍历期间原集合发生的修改迭代器是不知道的。
3.  **场景**：`java.util.concurrent`包下的容器都是安全失败，可以在多线程下并发使用，并发修改，比如`CopyOnWriteArrayList`类。

--------------------

## 2. fail-fast源码分析 ##

测试代码，使用IDEA进行debug

public static void main(String[] args) {
        
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        for (Integer integer : list) {
        
            System.out.println(integer);
        }
    }

这里的增强for循环实际上就是使用迭代器进行迭代的。迭代器记录了当前集合的修改次数。

int expectedModCount = modCount;

在for循环之前，`list`集合中添加了四个元素，所以在`list`中的`modCount`的值为4。

使用IDEA的debug工具，在程序执行过程中往`list`集合中添加一个元素——5，模拟并发。

![image-20230201234022290][]

![image-20230201234042067][]

成功往集合中添加第五个元素。

这时候，当下一次增强`for`循环执行的时候，也就是使用迭代器的`hasNext`方法

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

然后执行迭代器的`next`方法

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];
    }

首先，会调用`checkForComodification()`，检验集合是否被修改，如果修改，那么集合中的`mod`不会与`expectedModCount`相等。

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

`mod`与`expectedModCount`不相等，则会抛出`ConcurrentModificationException`异常，程序中断。

![image-20230201234738430][]

--------------------

## 3. fail-safe源码分析 ##

使用`CopyOnWriteArrayList`进行测试。

public static void main(String[] args) {
        
        CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        for (Integer integer : list) {
        
            System.out.println(integer);
        }
    }

先来简单阅读一下`CopyOnWriteArrayList`的源码

//底层存放数据的数组
    private transient volatile Object[] array;
    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();
        }
    }
    
    final Object[] getArray() {
        
        return array;
    }
    
    final void setArray(Object[] a) {
        
        array = a;
    }

`add`方法，它底层实现是加了`ReentrantLock`锁。

首先获取底层数组的长度。然后进行扩容。接着将需要添加进集合的元素放置在扩容后的数组的末端。

再将新数组`newElements`赋值给底层数组`array`。

接下来在增强`for`循环打断点。

![image-20230202123227242][]

在准备开始增强`for`循环的时候，会调用`iterator`创建一个`COWIterator`迭代器。

public Iterator<E> iterator() {
        
        return new COWIterator<E>(getArray(), 0);
    }

并且将底层存放数据的数组`array`作为参数。

//由后续调用next返回的元素的索引。
    private int cursor;
    //快照，存储的是迭代器进行迭代的时候，集合的数据
    private final Object[] snapshot;
    private COWIterator(Object[] elements, int initialCursor) {
        
        cursor = initialCursor;
        snapshot = elements;
    }

然后调用`hasNext`方法

public boolean hasNext() {
        
        return cursor < snapshot.length;
    }

接着，调用`next`方法，将快照的数组依次输出。

public E next() {
        
        if (! hasNext())
            throw new NoSuchElementException();
        return (E) snapshot[cursor++];
    }

假如这时候，线程B向集合中添加一个元素。但是迭代器中的`snapshot`并没有变化。

因为能`snapshot`在`COWIterator`初始化的时候已经固定了。即使接下来`array`发生改变。`snapshot`也依然不变。

所以迭代器输出的数据是迭代器创建那一刻之前的数据，迭代过程中无论集合原数据变成什么，都是输出旧数据。

--------------------

## 4. 总结 ##

1.  `ArrayList`是`fail-fast`的经典代表，遍历的同时不能修改，否则会抛出异常。
2.  `CopyOnWriteArrayList`是`fail-safe`的经典代表，遍历的同时可以修改，原理是读写分离。

--------------------

[image-20230201234022290]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/0f831dd535764e389a28beeaab5fa6c3.png
[image-20230201234042067]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/ed3e027405684ba18551d9bae89deb53.png
[image-20230201234738430]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/6bc7972248a54f1ebcfdd64d07281cac.png
[image-20230202123227242]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/33cee5bb12af48fda725855f344dcd21.png