活性失败、快速失败、安全失败

关于三种失败，在《Effective Java》79条避免过度同步中也有涉及。

活性失败

多线性并发时，如果A线程修改了共享变量，此时B线程感知不到此共享变量的变化，叫做活性失败。
如何解决活性失败，那就需要两个线程之间对此变量有happens-before关系，最常见的就是volatile 或 加锁。

快速失败(fail-fast)

对集合进行迭代时 如果有其他线程对集合进行添加、删除操作，迭代会快速报错。
抛出ConcurrentModificationException异常 ，叫做快速失败。
例：（HashMap同理）

import java.util.ArrayList;
import java.util.List;
class YfModel{
    private String name;
	public YfModel(String name) {
        this.name = name;
    }
	public String getName() {
        return name;
    }
	public void setName(String name) {
        this.name = name;
    }
}
public class ExceptionYf {
    public static void main(String[] args){
        YfModel yfModel = new YfModel("default1");
        YfModel yfMode2 = new YfModel("default2");
        YfModel yfMode3 = new YfModel("default3");
        YfModel yfMode4 = new YfModel("default4");
        YfModel yfMode5 = new YfModel("default5");
        List<YfModel> yfModelList = new ArrayList<>();
        yfModelList.add(yfModel);
        yfModelList.add(yfMode2);
        yfModelList.add(yfMode3);
        yfModelList.add(yfMode4);
		for(YfModel tempYfModel : yfModelList){
            System.out.println("valueModel="+ tempYfModel.getName());
            yfModelList.add(yfMode5);
        }
	}
}

报错：

Exception in thread "main" java.util.ConcurrentModificationException
 at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
 at java.util.ArrayList$Itr.next(ArrayList.java:859)
 at com.yangfei.test.exceptiontest.ExceptionYf.main(ExceptionYf.java:36)

注意：
快速失败只是检测集合的元素个数是否有变化，如果元素是一个对象，修改这个对象的话。并不会报错。

一个特殊的例子

迭代到倒数第2个元素时，此时删除元素不会抛出异常，如下：

public static void main(String[] args){
        YfModel yfModel = new YfModel("default1");
        YfModel yfMode2 = new YfModel("default2");
        YfModel yfMode3 = new YfModel("default3");
        YfModel yfMode4 = new YfModel("default4");
 
        List<YfModel> yfModelList = new ArrayList<>();
        yfModelList.add(yfModel);
        yfModelList.add(yfMode2);
        yfModelList.add(yfMode3);
        yfModelList.add(yfMode4);
         
        for(YfModel ffModel : yfModelList){
            System.out.println("current item="+ffModel);
            //倒数第2个迭代时 删除元素不报错。
            if(ffModel.getName().equals("default3")){
                yfModelList.remove(ffModel);
            }
        }
 
        System.out.println("yfModelList="+yfModelList);
}

输出：

current item=YfModel{name='default1'}
current item=YfModel{name='default2'}
current item=YfModel{name='default3'}
yfModelList=[YfModel{name='default1'}, YfModel{name='default2'}, YfModel{name='default4'}]

原因：ArrayList 循环时 每次调用next cursor值会自动加1，循环到倒数第2个元素时 cursor=size-1 (假设共5个元素，则cursor==4)
此时由于调用了remove方法 删除了一个元素,当前的size–后也变为了4
所以继续循环会先判断hasNext是否为true ,此时返回false,不再循环退出了，也就不会报错了(报错是next放过抛出的)

public boolean hasNext() {
    return cursor != size;
}
 
@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];
}

这种情况虽然不抛出异常 但最后一个元素实际是没有遍历到的，丢数据更可能导致隐患的严重的bug。
一句话：不要在非安全性的集合遍历中修改集合的结构（增、删）。
建议：
List Map的删除可以在iterator迭代器中进行。
List还可以使用removeif ,使用lamdba进行删除。

安全失败（fail-safe）

对集合迭代时对原集合进行一份拷贝，对拷贝的新元素进行迭代，这叫安全失败。
这样原集合的修改在迭代的过程中就不会感知。java并发集合框架下（java.util.concurrent）迭代都是安全失败的
例：

public boolean hasNext() {
    return cursor != size;
}
 
@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];
}

输出：

valueModel=default3
valueModel=default4
valueModel=default1
valueModel=default2

迭代过程中新增的元素 并不会输出。即使对对象元素的属性修改，也是感知不到的。导致加锁并没有起到用锁进行保护的作用，因此成为安全失败。