Java fail-fast 与 fail-safe 机制对比

关于fail-fast参考这篇文章：
  从 modCount 看 java集合 fail-fast 机制

一、fail-safe概述以及与fail-fast区别

首先 fail-safe 并不属于JavaSE规范术语，只是用以说明 fail-fast 与 non-fail fast 的区别。

这种机制的迭代器允许在迭代时修改集合，且不会抛出任何异常。不同的类实现方式有所不同，通常是因为"迭代"与"修改操作"使用的不是同一个数据数组，比如CopyOnWirteArrayList在修改时会创建一个原数组副本（只是新建一个数组，浅克隆）在新数组上修改后再将指针指向新数组，而此时迭代器中的指针仍指向原数组。
因此这种迭代器无法保证在迭代时获取的是最新数据，比如：(1)CopyOnWriteArrayList在迭代过程中的数据更新无法在迭代中表现出来。(2)ConcurrentHashMap的弱一致性迭代器。

注：弱一致性迭代器可能会（但不保证）将迭代过程中的修改表现出来。

ConcurrentHashMap迭代器官方注释：
The iterators returned by ConcurrentHashMap is weakly consistent. This means that this iterator can tolerate concurrent modification, traverses elements as they existed when iterator was constructed and may (but not guaranteed to) reflect modifications to the collection after the construction of the iterator.

二、示例

2.1 CopyOnWriteArrayList示例

    public static void main(String args[]) 
    { 
        CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<Integer>(new Integer[] { 1, 3, 5, 8 }); 
        Iterator itr = list.iterator(); 
        while (itr.hasNext()) { 
            Integer no = (Integer)itr.next(); 
            System.out.println(no); 
            if (no == 8) 
                list.add(14); //不会打印
        } 
    }

输出：

    1
    3
    5
    8

2.2 ConcurrentHashMap示例

    public static void main(String[] args) 
    { 
  
        // Creating a ConcurrentHashMap 
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String, Integer>(); 
  
        map.put("ONE", 1); 
        map.put("TWO", 2); 
        map.put("THREE", 3); 
        map.put("FOUR", 4); 
  
        // Getting an Iterator from map 
        Iterator it = map.keySet().iterator(); 
  
        while (it.hasNext()) { 
            String key = (String)it.next(); 
            System.out.println(key + " : " + map.get(key)); 
            //一般会打印
            //但若改成("FIVE",5)则基本不会打印，可能与弱一致性迭代器内部逻辑有关
            map.put("SEVEN", 7); 
        } 
    }

三、实现原理解析

3.1 CopyOnWriteArrayList对fail-safe实现

CopyOnWriteArrayList 在修改时会创建一个原数组副本（只是新建一个数组，浅克隆）在新数组上修改后再将集合的数组指针指向新数组对象，而此时迭代器中的指针仍指向原数组对象。迭代过程中的修改，不会反映到迭代上。

源码解析：

public class CopyOnWriteArrayList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    //！只放关键代码

    /** The array, accessed only via getArray/setArray. */
    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); //浅克隆原数组并长度+1
            newElements[len] = e; //在新数组上进行添加
            setArray(newElements); //将数组指针指向新数组
            return true;
        } finally {
            lock.unlock();
        }
    }

    //迭代器方法
    public Iterator<E> iterator() {
        return new COWIterator<E>(getArray(), 0); //直接用原来的数据数组
    }

    final Object[] getArray() {
        return array;
    }

    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; //将引用snapshot指向传入的原数组
        }
//…
        public E next() {
            if (! hasNext())
                throw new NoSuchElementException();
            return (E) snapshot[cursor++];
        }
    }
}

3.2 ConcurrentHashMap对fail-safe实现

ConcurrentHashMap并非通过拷贝数组修改来实现的fail-safe…
//TODO：

参考：
https://www.geeksforgeeks.org/fail-fast-fail-safe-iterators-java/