什么是fail-fast和fail-safe

fail-fast

fail-fast其实是一种设计理念，就是在系统设计之前先考虑异常，一旦发生异常就开始上报，举个简单例子

在divide方法中当我们这两个值中有其中一个为0便会抛出异常，并提示异常信息。这其实就是fail-fast的思想。
fail-fast 是一种很好的机制，但是使用不好也会是个“坑”
导致 fail-fast 机制报出异常一般是两种情况，1、并发的操作非安全类的集合，2、迭代器循环里进行remove/add的操作
演示两个例子

并发的操作非安全类的集合

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }

这种情况大家都很了解，可以换成JUC中的安全性集合，但是有时我们在开发中并没有用到多线程也会报ConcurrentModificationException异常，这种原因便是下面这种情况

迭代器循环里进行remove/add

public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(0);
        list.add(1);
        list.add(2);
        for(int n : list){
            list.remove(0);
            list.add(0, 4);
        }
    }

foreach的底层就是iterator等价于

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(0);
        list.add(1);
        list.add(2);
        for (Iterator<Integer> iterator = list.iterator(); iterator.hasNext(); ) {
            int num = iterator.next();
            if (num == 0) {
                list.remove(0);
                list.add(0, 4);
            }
        }
    }

整个过程中，iterator的指针只进行过一次定义，所以它的指针会保持为第一时的状态，然而在循环执行过程中，list集合发生了长度上的变动，所以对应的iterator指针也应该做相应的调整，因为物理位置发生了改变，但可惜的是，iterator还是保持第一次声明时的状态，所以这个时候iterator.next()指针所保持的物理地址已经不符合当前要求了，故会抛出java.util.ConcurrentModificationException该异常。

fail-safe

为了避免触发fail-fast机制导致的异常，我们采用fail-safe机制中的集合类

    public static void main(String[] args) {
        List<Integer> list = new CopyOnWriteArrayList<>();
        list.add(0);
        list.add(1);
        list.add(2);

        list.iterator();
        for (Integer num : list) {
            list.remove(0);
        }
        System.out.println(list);
    }

CopyOnWriteArrayList替换ArrayList，就不会抛出异常。
fail-safe 集合中的所有对集合的修改都是先复制一个副本。然后在副本上进行。并不会在原来的集合中进行修改。并且这些修改方法都是加锁进行控制的。
这种方法虽然避免了ConcurrentModificationException，但同样缺点也很明显。

public static void main(String[] args) {
        List<Integer> list = new CopyOnWriteArrayList<>();
        list.add(0);
        list.add(1);
        list.add(2);

        Iterator<Integer> iterator = list.iterator();
        for (Integer num : list) {
            if (num == 0) {
                list.remove(0);
            }
        }
        System.out.println(list);

        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
    }

[1, 2]
0 1 2 

迭代器开始遍历时获取到集合副本，在遍历期间愿集合发生修改，迭代器是无法感知到的。