概述
Java集合快速失败与安全失败
前言
我们在开发过程中有没有在遍历集合的时候遇到过ConcurrentModificationException这样的异常，那么什么样的原因导致这种异常呢？本篇博客将带领大家去了解一下Java集合fail-fast快速失败机制与fail-safe安全失败机制。
正文
fail-fast与fail-safe
- fail-fast快速失败机制： 是Java集合中的一种机制，在用迭代器遍历一个集合对象时，如果遍历过程中对集合对象的内容进行了修改（增加、删除、修改），则会抛出ConcurrentModificationException。
- fail-safe安全失败机制：java.util.concurrent包下的容器都是安全失败，在遍历时不是直接在集合内容上访问的，而是先copy原有集合内容,在拷贝的集合上进行遍历，因此采用安全失败的容器可以在多线程下并发使用，并发修改。
fail-fast快速失败机制
public class test {
public static void main(String[] args) {
testForHashMap();
}
private static void testForHashMap() {
HashMap<String,String> hashMap =new LinkedHashMap<>();
hashMap.put("1","a");
hashMap.put("2","b");
hashMap.put("3","c");
Iterator<Map.Entry<String,String>> iterator=hashMap.entrySet().iterator();
while (iterator.hasNext()) {
hashMap.put("bloom","bloom");
System.out.println(iterator.next());
}
}
}
快速失败机制下修改集合元素触发快速失败，输出结果：
遍历集合时,新增或者删除元素，将抛ConcurrentModificationException异常
fail-safe安全失败机制
public class test {
public static void main(String[] args) {
testForHashTable();
}
private static void testForHashTable() {
Hashtable<String,String> hashtable =new Hashtable();
hashtable.put("4","d");
hashtable.put("5","e");
hashtable.put("6","f");
Enumeration<String> iterator1=hashtable.elements();
while (iterator1.hasMoreElements()) {
hashtable.put("bloom","bloom");
System.out.println(iterator1.nextElement());
}
}
}
安全失败机制下修改集合元素，输出结果
我们可以在遍历集合的同时，新增、删除元素
小结一下
fail-fast，它是Java集合的一种错误检测机制。
在用迭代器遍历一个集合对象时，如果遍历过程中不应该对集合对象的内容进行了修改（增加、删除、修改），可以新建一个新的集合进行操作。
快速失败&安全失败（最全的总结）
public static void main(String[] args) {
Hashtable<String, String> table = new Hashtable<String, String>();
table.put("a", "aa");
table.put("b", "bb");
table.put("c", "cc");
table.remove("c");
Iterator<Entry<String, String>> iterator = table.entrySet().iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next().getValue());
//采用iterator直接进行修改 程序正常
iterator.remove();
//直接从hashtable增删数据就会报错
table.put("d", "dd");
//直接从hashtable增删数据就会报错，hashtable，hashmap等非并发集合，如果在迭代过程中增减了数据，就是快速失败
table.remove("c");
}
System.out.println("-----------");
Lock lock = new ReentrantLock();
//即使加上lock，还是会跑出ConcurrentModificationException异常
lock.lock();
HashMap<String, String> hashmap = new HashMap<String, String>();
hashmap.put("a", "aa");
hashmap.put("b", "bb");
hashmap.put("c", "cc");
Iterator<Entry<String, String>> iterators = hashmap.entrySet().iterator();
while (iterators.hasNext()) {
System.out.println(iterators.next().getValue());
// 正常
iterators.remove();
//直接从hashtable增删数据就会报错。
//hashtable，hashmap等非并发集合，如果在迭代过程中增减了数据，会快速失败 (一检测到修改，马上抛异常)
//java.util.ConcurrentModificationException
hashmap.remove("c");
}
System.out.println("-----------");
lock.unlock();
ConcurrentHashMap<String, String> map = new ConcurrentHashMap<String, String>();
map.put("a", "aa");
map.put("b", "bb");
map.put("c", "cc");
Iterator<Entry<String, String>> mapiterator = map.entrySet().iterator();
while (mapiterator.hasNext()) {
System.out.println(mapiterator.next().getValue());
map.remove("c");// 正常 并发集合不存在快速失败问题
map.put("c", "cc");// 正常 并发集合不存在快速失败问题
}
System.out.println("-----------");
}
运行该段代码发现，在Hashtable和HashMap的循环迭代过程中在容器对象上做“修改”操作的话，是跑出java.util.ConcurrentModificationException异常，在Iterator上做操作不会异常。但是ConcurrentHashMap在容器对象和Iterator对象上都不会抛异常，这是为什么呢？
（1）首先来介绍两个概念，快速失败和安全失败。
Iterator的安全失败是基于对底层集合做拷贝，因此，它不受源集合上修改的影响。java.util包下面的所有的集合类都是快速失败的，而java.util.concurrent包下面的所有的类都是安全失败的。
快速失败的迭代器会抛出ConcurrentModificationException异常，而安全失败的迭代器永远不会抛出这样的异常。
（2）我们查看Hashtable、HashMap、ConcurrentHashMap的在Java API底层的entrySet对象发现，三者都做了对当前对象的拷贝，三者的处理方式是一样的，那区别在哪里呢？看看获取下一个entrySet在逻辑上的区别
这是Hashtable、HashMap的
final Node<K,V> nextNode() {
Node<K,V>[] t;
Node<K,V> e = next;
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
if (e == null)
throw new NoSuchElementException();
if ((next = (current = e).next) == null && (t = table) != null) {
do {} while (index < t.length && (next = t[index++]) == null);
}
return e;
}
这是ConcurrentHashMap的
public final Map.Entry<K,V> next() {
Node<K,V> p;
if ((p = next) == null)
throw new NoSuchElementException();
K k = p.key;
V v = p.val;
lastReturned = p;
advance();
return new MapEntry<K,V>(k, v, map);
}
/**
* Advances if possible, returning next valid node, or null if none.
*/
final Node<K,V> advance() {
Node<K,V> e;
if ((e = next) != null)
e = e.next;
for (;;) {
Node<K,V>[] t; int i, n; // must use locals in checks
if (e != null)
return next = e;
if (baseIndex >= baseLimit || (t = tab) == null ||
(n = t.length) <= (i = index) || i < 0)
return next = null;
if ((e = tabAt(t, i)) != null && e.hash < 0) {
if (e instanceof ForwardingNode) {
tab = ((ForwardingNode<K,V>)e).nextTable;
e = null;
pushState(t, i, n);
continue;
}
else if (e instanceof TreeBin)
e = ((TreeBin<K,V>)e).first;
else
e = null;
}
if (stack != null)
recoverState(n);
else if ((index = i + baseSize) >= n)
index = ++baseIndex; // visit upper slots if present
}
}
ConcurrentHashMap中的迭代器主要包括entrySet、keySet、values方法。它们大同小异，这里选择entrySet解释。当我们调用entrySet返回值的iterator方法时，返回的是EntryIterator，在EntryIterator上调用next方法时，最终实际调用到了HashIterator.advance()方法。这个方法在遍历底层数组。
在遍历过程中，如果已经遍历的数组上的内容变化了，迭代器不会抛出ConcurrentModificationException异常。如果未遍历的数组上的内容发生了变化，则有可能反映到迭代过程中。
这就是ConcurrentHashMap迭代器弱一致的表现。ConcurrentHashMap的弱一致性主要是为了提升效率，是一致性与效率之间的一种权衡。要成为强一致性，就得到处使用锁，甚至是全局锁，这就与Hashtable和同步的HashMap一样了。
最后我们看看JDK中对于快速失败的描述：
注意，此实现不是同步的。如果多个线程同时访问一个哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须 保持外部同步。（结构上的修改是指添加或删除一个或多个映射关系的任何操作；仅改变与实例已经包含的键关联的值不是结构上的修改。）这一般通过对自然封装该映射的对象进行同步操作来完成。
如果不存在这样的对象，则应该使用 Collections.synchronizedMap 方法来“包装”该映射。最好在创建时完成这一操作，以防止对映射进行意外的非同步访问，如下所示： Map m = Collections.synchronizedMap(new HashMap(...));由所有此类的“collection 视图方法”所返回的迭代器都是快速失败 的：在迭代器创建之后，如果从结构上对映射进行修改，除非通过迭代器本身的 remove 方法，其他任何时间任何方式的修改，迭代器都将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不冒在将来不确定的时间发生任意不确定行为的风险。
注意，迭代器的快速失败行为不能得到保证，一般来说，存在非同步的并发修改时，不可能作出任何坚决的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的做法是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测程序错误。
以上为个人经验，希望能给大家一个参考，也希望大家多多支持靠谱客。
最后
以上就是义气白昼为你收集整理的Java集合快速失败与安全失败解析的全部内容，希望文章能够帮你解决Java集合快速失败与安全失败解析所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
发表评论 取消回复