1、什么是 fail-fast
维基百科中关于fail-fast的解释:
在系统设计中,快速失效系统一种可以立即报告任何可能表明故障的情况的系统。快速失效系统通常设计用于停止正常操作,而不是试图继续可能存在缺陷的过程。这种设计通常会在操作中的多个点检查系统的状态,因此可以及早检测到任何故障。快速失败模块的职责是检测错误,然后让系统的下一个最高级别处理错误。
其实,这是一种理念,fail-fast就是在做系统设计的时候先考虑异常情况,一旦发生异常,直接停止并上报。
举一个最简单的fail-fast的例子:
public int divide(int divisor,int dividend){
if(dividend == 0){
throw new RuntimeException("dividend can't be null");
}
return divisor/dividend;
}
上面的代码是一个对两个整数做除法的方法,在divide方法中,我们对被除数做了个简单的检查,如果其值为0,那么就直接抛出一个异常,并明确提示异常原因。这其实就是fail-fast理念的实际应用。
这样做的好处就是可以预先识别出一些错误情况,一方面可以避免执行复杂的其他代码,另外一方面,这种异常情况被识别之后也可以针对性的做一些单独处理。
但是,Java 中的部分集合类中运用了fail-fast机制进行设计,一旦使用不当,触发fail-fast机制设计的代码,就会发生非预期情况。
2、集合类中的 fail-fast
我们通常说的Java中的fail-fast机制,默认指的是Java集合的一种错误检测机制。在使用迭代器对集合对象进行遍历的时候,如果 A 线程正在对集合进行遍历,此时 B 线程对集合进行修改(增加、删除),或者 A 线程在遍历过程中对集合进行修改,都会导致 A 线程抛出ConcurrentModificationException 异常。
示例:
单线程,在foreach 循环里对某些集合元素进行元素的 remove/add 操作的时候,就会触发fail-fast机制
public static void main(String[] args) {
List<String> strList = new ArrayList<>();
strList.add("AA");
strList.add("aa");
strList.add("BB");
strList.add("CC");
for (String str : strList) {
if ("aa".equals(str)) {
strList.remove(str);
}
}
System.out.println(strList);
}
运行结果:
多线程,在一个线程读时,另一个线程写入list,读线程会快速失败
public class FailFastMultiThreadDemo {
public static void main(String[] args) {
List<String> strList = new ArrayList<>();
strList.add("AA");
strList.add("aa");
strList.add("BB");
strList.add("CC");
strList.add("DD");
strList.add("EE");
new MyThread1(strList).start();
new MyThread2(strList).start();
}
static class MyThread1 extends Thread {
private List<String> list;
public MyThread1(List<String> list) {
this.list = list;
}
@Override
public void run() {
for (String str : list) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("MyThread1 " + str);
}
}
}
static class MyThread2 extends Thread {
private List<String> list;
public MyThread2(List<String> list) {
this.list = list;
}
@Override
public void run() {
for (int i = 0; i < list.size(); i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
if ("aa".equals(list.get(i))) {
list.remove(i);
}
}
System.out.println("MyThread2 " + list);
}
}
}
运行结果:
3、原理分析
将单线程实例代码编译后的的 .class 进行反编译,得到以下代码
public static void main(String[] args) {
List<String> strList = new ArrayList();
strList.add("AA");
strList.add("aa");
strList.add("BB");
strList.add("CC");
Iterator var2 = strList.iterator();
while(var2.hasNext()) {
String str = (String)var2.next();
if ("aa".equals(str)) {
strList.remove(str);
}
}
System.out.println(strList);
}
可以发现,foreach其实是依赖了while循环和Iterator实现的。
通过以上代码的异常堆栈,可以跟踪到真正抛出异常的代码是:
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
该方法是在iterator.next()方法中调用的。看下该方法的实现:
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
如上,在该方法中对modCount和expectedModCount进行了比较,如果二者不想等,则抛出CMException。
那么,modCount和expectedModCount是什么?是什么原因导致他们的值不想等的呢?
modCount是ArrayList中的一个成员变量。它表示该集合实际被修改的次数。
expectedModCount 是 ArrayList中的一个内部类——Itr中的成员变量。
Iterator var2 = strList.iterator();
以上代码,即可得到一个 Itr类,该类实现了Iterator接口。
expectedModCount表示这个迭代器预期该集合被修改的次数。其值随着Itr被创建而初始化。只有通过迭代器对集合进行操作,该值才会改变。
那么,接着我们看下userNames.remove(userName);方法里面做了什么事情,为什么会导致expectedModCount和modCount的值不一样。
通过翻阅代码,我们也可以发现,remove方法核心逻辑如下:
private void fastRemove(int index) {
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
}
可以看到,remove方法只修改了modCount,并没有对expectedModCount做任何操作。
简单总结一下,之所以会抛出CMException异常,是因为代码中使用了增强for循环,而在增强for循环中,集合遍历是通过iterator进行的,但是元素的add/remove却是直接使用的集合类自己的方法。这就导致iterator在遍历的时候,会发现有一个元素在自己不知不觉的情况下就被删除/添加了,就会抛出一个异常,用来提示用户,可能发生了并发修改!
所以,在使用Java的集合类的时候,如果发生CMException,优先考虑fail-fast有关的情况,实际上这里并没有真的发生并发,只是Iterator使用了fail-fast的保护机制,只要他发现有某一次修改是未经过自己进行的,那么就会抛出异常。
阿里巴巴开发手册中也有明确规定:
4、解决方式
使用普通 for 循环进行操作
我们说不能在foreach中进行,但是使用普通的for循环还是可以的,因为普通for循环并没有用到Iterator的遍历,所以也不会进行fail-fast的检验。
public static void main(String[] args) {
List<String> strList = new ArrayList<>();
strList.add("AA");
strList.add("aa");
strList.add("BB");
strList.add("CC");
for (int i = 0; i < strList.size(); i++) {
if ("aa".equals(strList.get(i))) {
strList.remove(i);
}
}
System.out.println(strList);
}
但是删除多个元素时不建议使用,可能会漏删
直接使用 Iterator 进行操作
public static void main(String[] args) {
List<String> strList = new ArrayList<>();
strList.add("AA");
strList.add("aa");
strList.add("aa");
strList.add("CC");
Iterator<String> iterator = strList.iterator();
while (iterator.hasNext()) {
if ("aa".equals(iterator.next())) {
iterator.remove();
}
}
System.out.println(strList);
}
如果直接使用Iterator提供的remove方法,那么就可以修改expectedModCount的值。那么就不会再抛出异常了。其实现代码如下:
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
使用 Java 8 中提供的 filter 过滤
Java 8中可以把集合转换成流,对于流有一种filter操作, 可以对原始 Stream 进行某项测试,通过测试的元素被留下来生成一个新 Stream。
public static void main(String[] args) {
List<String> strList = new ArrayList<>();
strList.add("AA");
strList.add("aa");
strList.add("aa");
strList.add("CC");
strList = strList.stream().filter(e -> !"aa".equals(e)).collect(Collectors.toList());
System.out.println(strList);
}
使用 fail-safe 的集合类
为了避免触发fail-fast机制导致异常,我们可以使用Java中提供的一些采用了fail-safe机制的集合类。
CopyOnWrite容器即写时复制的容器。通俗的理解是当我们往一个容器添加元素的时候,不直接往当前容器添加,而是先将当前容器进行Copy,复制出一个新的容器,然后新的容器里添加元素,添加完元素之后,再将原容器的引用指向新的容器。
java.util.concurrent包下的容器都是fail-safe的,可以在多线程下并发使用,并发修改。同时也可以在foreach中进行add/remove 。
public static void main(String[] args) {
List<String> strList = new CopyOnWriteArrayList<>();
strList.add("AA");
strList.add("aa");
strList.add("BB");
strList.add("CC");
Iterator<String> iterator = strList.iterator();
for (String str : strList) {
if ("aa".equals(str)) {
strList.remove(str);
}
}
System.out.println(strList);
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
以上代码,使用CopyOnWriteArrayList代替了ArrayList,就不会发生异常。
但是,虽然基于拷贝内容的优点是避免了ConcurrentModificationException,但同样地,迭代器并不能访问到修改后的内容。运行结果如下:
缺点:
1、内存占用问题:因为要复制集合对象,导致内存开销大
2、数据一致性问题:CopyOnWrite容器只能保证数据的最终一致性,不能保证数据的实时一致性。所以如果你希望写入的的数据,马上能读到,请不要使用CopyOnWrite容器。
也可以使用增强 for 循环
如果,我们非常确定在一个集合中,某个即将删除的元素只包含一个的话, 也是可以使用增强for循环,只要在删除之后,立刻结束循环体,不要再继续进行遍历就可以了,也就是说不让代码执行到下一次的next方法。
public static void main(String[] args) {
List<String> strList = new CopyOnWriteArrayList<>();
strList.add("AA");
strList.add("aa");
strList.add("BB");
strList.add("CC");
for (String str : strList) {
if ("aa".equals(str)) {
strList.remove(str);
break;
}
}
System.out.println(strList);
}
5、总结
我们使用的增强for循环,其实是Java提供的语法糖,其实现原理是借助Iterator进行元素的遍历。
但是如果在遍历过程中,不通过Iterator,而是通过集合类自身的方法对集合进行添加/删除操作。那么在Iterator进行下一次的遍历时,经检测发现有一次集合的修改操作并未通过自身进行,那么可能是发生了并发被其他线程执行的,这时候就会抛出异常,来提示用户可能发生了并发修改,这就是所谓的fail-fast机制。