【Java学习】快速失败(fail-fast)和安全失败(fail-safe)

ゝ一世哀愁。 2021-10-03 02:06 443阅读 0赞

### 1.快速失败和安全失败的区别 ###

Iterator的安全失败是基于对底层集合做拷贝，因此，它不受源集合上修改的影响。java.util包下面的所有的集合类都是快速失败的，而java.util.concurrent包下面的所有的类都是安全失败的。快速失败的迭代器会抛出ConcurrentModificationException异常，而安全失败的迭代器永远不会抛出这样的异常。

### 2.快速失败的例子 ###

package bite18.快速失败和安全失败;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    /**
     * ⊙﹏⊙&&&&&&⊙▽⊙
     *
     * @Auther: pangchenbo
     * @Date: 2020/4/12 23:29
     * @Description:
     */
    public class Test {
        private static List<Integer> list = new ArrayList<>();
    
    
        private static class threadOne extends Thread{
            public void run() {
                Iterator<Integer> iterator = list.iterator();
                while(iterator.hasNext()){
                    int i = iterator.next();
                    System.out.println("ThreadOne 遍历:" + i);
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
        private static class threadTwo extends Thread{
            public void run(){
                int i = 0 ;
                while(i < 6){
                    System.out.println("ThreadTwo run：" + i);
                    if(i == 3){//进行修改
                        list.remove(i);
                    }
                    i++;
                }
            }
        }
    
        public static void main(String[] args) {
            for(int i = 0 ; i < 10;i++){
                list.add(i);
            }
            new threadOne().start();
            new threadTwo().start();
        }
    
    
    }

结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzI3MTA4Ng_size_16_color_FFFFFF_t_70][]

### 3.快速失败原因分析 ###

通过上面的例子可以看出，线程2在线程1在遍历的过程中对collection接口在结构上进行修改，这个时候迭代器就会抛出一个ConcurrentModificationException，这就产生了fail-fast。

要了解fail-fast机制，我们首先要对ConcurrentModificationException 异常有所了解。当方法检测到对象的并发修改，但不允许这种修改时就抛出该异常。同时需要注意的是，该异常不会始终指出对象已经由不同线程并发修改，如果单线程违反了规则，同样也有可能会抛出改异常。

诚然，迭代器的快速失败行为无法得到保证，它不能保证一定会出现该错误，但是快速失败操作会尽最大努力抛出ConcurrentModificationException异常，所以因此，为提高此类操作的正确性而编写一个依赖于此异常的程序是错误的做法，正确做法是：ConcurrentModificationException 应该仅用于检测 bug。下面我将以ArrayList为例进一步分析fail-fast产生的原因。

我们先看看Iterator的源码。ArrayList的Iterator是在父类AbstractList.java中实现的

package java.util;
    
    public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
    
        ...
    
        // AbstractList中唯一的属性
        // 用来记录List修改的次数：每修改一次(添加/删除等操作)，将modCount+1
        protected transient int modCount = 0;
    
        // 返回List对应迭代器。实际上，是返回Itr对象。
        public Iterator<E> iterator() {
            return new Itr();
        }
    
        // Itr是Iterator(迭代器)的实现类
        private class Itr implements Iterator<E> {
            int cursor = 0;
    
            int lastRet = -1;
    
            // 修改数的记录值。
            // 每次新建Itr()对象时，都会保存新建该对象时对应的modCount；
            // 以后每次遍历List中的元素的时候，都会比较expectedModCount和modCount是否相等；
            // 若不相等，则抛出ConcurrentModificationException异常，产生fail-fast事件。
            int expectedModCount = modCount;
    
            public boolean hasNext() {
                return cursor != size();
            }
    
            public E next() {
                // 获取下一个元素之前，都会判断“新建Itr对象时保存的modCount”和“当前的modCount”是否相等；
                // 若不相等，则抛出ConcurrentModificationException异常，产生fail-fast事件。
                checkForComodification();
                try {
                    E next = get(cursor);
                    lastRet = cursor++;
                    return next;
                } catch (IndexOutOfBoundsException e) {
                    checkForComodification();
                    throw new NoSuchElementException();
                }
            }
    
            public void remove() {
                if (lastRet == -1)
                    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() {
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
            }
        }
    
        ...
    }

从中，我们可以发现在调用 next() 和 remove()时，都会执行** checkForComodification()**。若 “**modCount 不等于 expectedModCount**”，则抛出ConcurrentModificationException异常，产生fail-fast事件。

要搞明白 fail-fast机制，我们就要需要理解什么时候“modCount 不等于 expectedModCount”！  
从Itr类中，我们知道 expectedModCount 在创建Itr对象时，被赋值为 modCount。通过Itr，我们知道：expectedModCount不可能被修改为不等于 modCount。所以，需要考证的就是modCount何时会被修改。

接下来，我们查看ArrayList的源码，来看看modCount是如何被修改的。

package java.util;
    
    public class ArrayList<E> extends AbstractList<E>
            implements List<E>, RandomAccess, Cloneable, java.io.Serializable
    {
    
        ...
    
        // list中容量变化时，对应的同步函数
        public void ensureCapacity(int minCapacity) {
            modCount++;
            int oldCapacity = elementData.length;
            if (minCapacity > oldCapacity) {
                Object oldData[] = elementData;
                int newCapacity = (oldCapacity * 3)/2 + 1;
                if (newCapacity < minCapacity)
                    newCapacity = minCapacity;
                // minCapacity is usually close to size, so this is a win:
                elementData = Arrays.copyOf(elementData, newCapacity);
            }
        }
    
    
        // 添加元素到队列最后
        public boolean add(E e) {
            // 修改modCount
            ensureCapacity(size + 1);  // Increments modCount!!
            elementData[size++] = e;
            return true;
        }
    
    
        // 添加元素到指定的位置
        public void add(int index, E element) {
            if (index > size || index < 0)
                throw new IndexOutOfBoundsException(
                "Index: "+index+", Size: "+size);
    
            // 修改modCount
            ensureCapacity(size+1);  // Increments modCount!!
            System.arraycopy(elementData, index, elementData, index + 1,
                 size - index);
            elementData[index] = element;
            size++;
        }
    
        // 添加集合
        public boolean addAll(Collection<? extends E> c) {
            Object[] a = c.toArray();
            int numNew = a.length;
            // 修改modCount
            ensureCapacity(size + numNew);  // Increments modCount
            System.arraycopy(a, 0, elementData, size, numNew);
            size += numNew;
            return numNew != 0;
        }
       
    
        // 删除指定位置的元素 
        public E remove(int index) {
            RangeCheck(index);
    
            // 修改modCount
            modCount++;
            E oldValue = (E) elementData[index];
    
            int numMoved = size - index - 1;
            if (numMoved > 0)
                System.arraycopy(elementData, index+1, elementData, index, numMoved);
            elementData[--size] = null; // Let gc do its work
    
            return oldValue;
        }
    
    
        // 快速删除指定位置的元素 
        private void fastRemove(int index) {
    
            // 修改modCount
            modCount++;
            int numMoved = size - index - 1;
            if (numMoved > 0)
                System.arraycopy(elementData, index+1, elementData, index,
                                 numMoved);
            elementData[--size] = null; // Let gc do its work
        }
    
        // 清空集合
        public void clear() {
            // 修改modCount
            modCount++;
    
            // Let gc do its work
            for (int i = 0; i < size; i++)
                elementData[i] = null;
    
            size = 0;
        }
    
        ...
    }

从中，我们发现：无论是add()、remove()，还是clear()，只要涉及到修改集合中的元素个数时，都会改变modCount的值。

### 4.**解决fail-fast的原理** ###

上面，说明了“解决fail-fast机制的办法”，也知道了“fail-fast产生的根本原因”。接下来，我们再进一步谈谈java.util.concurrent包中是如何解决fail-fast事件的。  
还是以和ArrayList对应的CopyOnWriteArrayList进行说明。我们先看看CopyOnWriteArrayList的源码：

package java.util.concurrent;
    import java.util.*;
    import java.util.concurrent.locks.*;
    import sun.misc.Unsafe;
    
    public class CopyOnWriteArrayList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    
        ...
    
        // 返回集合对应的迭代器
        public Iterator<E> iterator() {
            return new COWIterator<E>(getArray(), 0);
        }
    
        ...
       
        private static class COWIterator<E> implements ListIterator<E> {
            private final Object[] snapshot;
    
            private int cursor;
    
            private COWIterator(Object[] elements, int initialCursor) {
                cursor = initialCursor;
                // 新建COWIterator时，将集合中的元素保存到一个新的拷贝数组中。
                // 这样，当原始集合的数据改变，拷贝数据中的值也不会变化。
                snapshot = elements;
            }
    
            public boolean hasNext() {
                return cursor < snapshot.length;
            }
    
            public boolean hasPrevious() {
                return cursor > 0;
            }
    
            public E next() {
                if (! hasNext())
                    throw new NoSuchElementException();
                return (E) snapshot[cursor++];
            }
    
            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();
            }
        }
      
        ...
    
    }

可以看出，) ArrayList的iterator()函数返回的Iterator是在AbstractList中实现的；而CopyOnWriteArrayList是自己实现Iterator，在它自己的Iterator中实现了对数组的复制，这样就算原数据做出怎样的改变，都不会影响结果。更不会抛出异常了。

参考文章：[https://www.cnblogs.com/shamo89/p/6685216.html][https_www.cnblogs.com_shamo89_p_6685216.html]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzI3MTA4Ng_size_16_color_FFFFFF_t_70]: /images/20211003/3c334f78e17b43fabda2258544ea0309.png
[https_www.cnblogs.com_shamo89_p_6685216.html]: https://www.cnblogs.com/shamo89/p/6685216.html