fail-fast
fail-fast是一个理念。在系统设计时先考虑异常情况,一旦发生异常,直接停止并上报。例如:
public int divide(int dividend,int divisor){
// 预先识别出一些错误的情况
if(divisor == 0){
throw new RuntimeException("divisor can't be zero");
}
return dividend/divisor;
}
集合中的fail-fast
在Java中,集合类中有用到fail-fast机制进行设计,一旦使用不当,触发fail-fast机制设计的代码,就会发生非预期情况。
在集合类中,为了避免并发修改,会维护一个expectedModCount属性,他表示这个迭代器预期该集合被修改的次数。还有一个modCount属性,他表示该集合实际被修改的次数。在集合被修改时,会去比较modCount和expectedModCount的值,如果不一致,则会触发fail-fast机制,抛出 ConcurrentModificationException。
我们通常说的Java中的fail-fast机制,默认指的是Java集合的一种错误检测机制。当多个线程对部分集合进行结构上的改变的操作时,有可能会产生fail—fast机制,这个时候就会抛出ConcurrentModificationException
ConcurrentModificationException,当方法检测到对象的并发修改,但不允 许这种修改时就抛出该异常。
在Java中,如果在foreach循环里对某些集合元素进行元素的remove/add操作的时候,就会触发fail-fast机制,进而抛出ConcurrentModificationException.
foreach遍历数组
语法糖形式
int[] numbers = {1, 2, 3, 4, 5};
for (int number : numbers) {
System.out.println(number);
}
解语法糖
Iterator iterator = numbers.iterator();
do{
if(!iterator.hasNext()) break;
int number = (String)iterator.next();
} while(true);
可以发现,foreach其实是依赖了while循环和Iterator实现的。
注意事项
foreach只能对原集合进行读取,不能对原集合进行写入
迭代器导致并发修改异常的原因分析
- 每次调用ArrayList的iterator()方法都会返回一个迭代器
- 每个迭代器中的cursor记录着当前迭代器的偏移量
- 在迭代的过程中,如果元素发生变化,那么偏移量也要发生变化,否则遍历的元素会不准确
- 为了避免这种情况的发生,迭代器使用快速失败机制停止了增删等异常操作
- 如果直接对增删,使用fastRemove()与add()会执行modCount++,在next中调用checkForComodification()进行判断
public class ArrayList<E> {
private void fastRemove(Object[] es, int i) {
modCount++;
final int newSize;
if ((newSize = size - 1) > i)
System.arraycopy(es, i + 1, es, i, newSize - i);
es[size = newSize] = null;
}
public boolean add(E e) {
modCount++;
add(e, elementData, size);
return true;
}
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
// prevent creating a synthetic constructor
Itr() {}
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];
}
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();
}
}
@Override
public void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
final int size = ArrayList.this.size;
int i = cursor;
if (i < size) {
final Object[] es = elementData;
if (i >= es.length)
throw new ConcurrentModificationException();
for (; i < size && modCount == expectedModCount; i++)
action.accept(elementAt(es, i));
// update once at end to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
}
fail-fast总结
之所以会抛出CMException异常,是因为我们的代码中使用了增强for循环,而在增强for循环中,集合遍历是通过iterator进行的,但是元素的add/remove却是直接使用的集合类自己的方法。这就导致iterator在遍历的时候,会发现有一个元素在自己不知不觉的情况下就被删除/添加了,就会抛出一个异常,用来提示用户,可能发生了并发修改!
所以,在使用Java的集合类的时候,如果发生CMException,优先考虑fail-fast 有关的情况,实际上这里并没有真的发生并发,只是Iterator使用了fail—fast的保护机制,只要他发现有某一次修改是未经过自己进行的,那么就会抛出异常。
fail-safe
为了避免触发fail-fast机制,导致异常,我们可以使用Java中提供的一些采用了fail-safe机制的集合类。
public class CopyOnWriteArrayListCode {
public static void main(String[] args) {
List<String> userNames = new CopyOnWriteArrayList<>() {
{
add("aaa");
add("bbb");
add("bbb");
add("ddd");
}
};
for (String userName : userNames) {
if(userName.equals("bbb")) {
userNames.remove(userName);
}
}
System.out.println(userNames);
}
}
CopyOnWriteArrayList的原理是在修改集合之前先拷贝一个副本,然后在副本集合上进行操作,并不会直接对原集合进行修改。
CopyOnWrite容器即写时复制的容器。通俗的理解是当我们往一个容器添加元素的时候,不直接往当前容器添加,而是先将当前容器进行Copy,复制出一个新的容器,然后新的容器里添加元素,添加完元素之后,再将原容器的引用指向新的容器。
迭代器遍历的是开始遍历那一刻拿到的集合拷贝,在遍历期间原集合发生的修改迭代器是不知道的。
基于拷贝内容的优点是避免了ConcurrentModificationException,但同样地,迭代器并不能访问到修改后的内容。
CopyOnWriteArrayList中add/remove等写方法是需要加锁的,目的是为了避免Copy出N个副本出来,导致并发写。
但是,CopyOnWriteArrayList中的读方法是没有加锁的。