快速失败（fail-fast）和安全失败（fail-safe）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.junit.Test;

/*
 * 说明：
 * modCount这个值是一个代表修改次数的字段，当对集合进行添加、删除、修改时，都会改变modCount的值。
 * 当使用list.iterator()返回一个迭代器对象时，迭代器对象有一个属性expectedModCount，被赋值为该方法调用时的modCount值。
 * 
 * 快速失败机制（fail-fast）：是当遍历一个集合对象时，如果集合对象的结构被修改了，则会
 * 抛出java.util.ConcurrentModificationException异常。
 * 原因是在遍历集合对象的时候，首先会对modCount这个值进行判断（checkForComodification），
 * 如果expectedModCount!=modCount时，就会抛出异常。
 */
public class Fail_FastTest {
	
	/*
	 * 使用Iterator遍历list，然后用list.remove移除数据
	 * （结果：抛出java.util.ConcurrentModificationException异常）
	 */
	@Test
	public void test01() {
		List<String> list=new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		Iterator<String> it=list.iterator();
		while(it.hasNext()){
			String str = it.next();
			System.out.println(str);
			if("a".equals(str)){
				list.remove(str);
			}
		}
	}
	
	/*
	 * 使用foreach遍历list，然后用list.remove移除数据
	 * （结果：抛出ConcurrentModificationException）
	 */
	@Test
	public void test02(){
		List<String> list=new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		for (String str : list) {
			if("a".equals(str)){
				list.remove(str);
			}
		}
	}
	
	/*
	 * 使用Iterator遍历，使用iterator.remove方法移除数据
	 * （结果：成功执行）
	 * 原因：iterator的remove方法没有进行modCount值的检查，
	 * 并且手动把expectedModCount值改成了当前的modCount值，保证了下一次迭代的准确。
	 */
	@Test
	public void test03(){
		List<String> list=new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		Iterator<String> it=list.iterator();
		while(it.hasNext()){
			String str=it.next();
			if("a".equals(str)){
				it.remove();
			}
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;
import org.junit.Test;

/*
 * 说明：并发容器的iterate方法返回的iterator对象，内部都是保存了该集合对象的一个快照副本，
 * 并且没有modCount等数值的检查。
 * Fail-Safe：是针对线程安全而出现的，由于并发容器的iterate读取的数据是某个时间点的快照版本。
 * 在并发容器中进行修改操作不会抛出异常，但因为它是工作在集合副本上的，而非集合本身。
不保证下次遍历的时候数据是否与当前集合对象的状态一致
 * 
 * 在java.util.Concurrent包中集合的迭代器，如ConcurrentHashMap、CopyOnWriteArrayList等默认为都是Fail-Safe。
 */
public class Fail_SafeTest {

	/*
	 * 使用Iterator遍历CopyOnWriteArrayList，并使用CopyOnWriteArrayList.remove来删除数据
	 */
	@Test
	public void test01(){
		CopyOnWriteArrayList<String> list=new CopyOnWriteArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		Iterator<String> it=list.iterator();
		while(it.hasNext()){
			String str=it.next();
			if("a".equals(str)){
				list.remove(str);
			}
		}
	}
	
	/*
	 * 使用forEach遍历CopyOnWriteArrayList，并使用CopyOnWriteArrayList.remove来删除数据
	 */
	@Test
	public void test02(){
		CopyOnWriteArrayList<String> list=new CopyOnWriteArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		for (String str : list) {
			if("a".equals(str)){
				list.remove(str);
			}
		}
	}
	
	/*
	 * 使用Iterator遍历CopyOnWriteArrayList，并使用iterator.remove来删除数据
	 * （结果：抛出java.lang.UnsupportedOperationException）
	 * CopyOnWriteArrayList在做迭代之前是做了一份”快照”,
	 * 所以此时的iter是不可变的，也就是说假设在此遍历中调用iter.remove()会抛出异常 
	 */
	@Test
	public void test03(){
		CopyOnWriteArrayList<String> list=new CopyOnWriteArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		Iterator<String> it=list.iterator();
		while(it.hasNext()){
			String str=it.next();
			if("a".equals(str)){
				it.remove();
			}
		}
	}
}