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

1、活性失败

多线性并发时，如果A线程修改了共享变量，此时B线程感知不到此共享变量的变化，叫做活性失败。

如何解决活性失败，那就需要两个线程之间对此变量有happens-before关系，最常见的就是volatile 或加锁。

2、快速失败(fail-fast)

2.1 对集合进行迭代时如果有其他线程对集合进行添加删除操作，迭代会快速报错。

抛出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);
        }

    }
}

View Code

报错：

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.2 一个特殊的例子

迭代到倒数第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进行删除。

3、安全失败（fail-safe）

对集合迭代时对原集合进行一份拷贝，对拷贝的新元素进行迭代，这叫安全失败

这样原集合的修改在迭代的过程中就不会感知。java并发集合框架下（java.util.concurrent）迭代都是安全失败的

例：

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

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);

        Map<String,YfModel> yfMap = new ConcurrentHashMap<>();
        yfMap.put("default1",yfModel);
        yfMap.put("default2",yfMode2);
        yfMap.put("default3",yfMode3);
        yfMap.put("default4",yfMode4);

        for(Map.Entry<String, YfModel>  entry : yfMap.entrySet()){
            System.out.println("valueModel="+ entry.getValue().getName());
            yfMap.put("default5",yfMode5);
        }
    }
}

View Code

输出：

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

迭代过程中新增的元素并不会输出。即使对对象元素的属性修改，也是感知不到的。

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

推荐阅读