碼代碼的時候發現了這個異常,java.util.ConcurrentModificationException,倒是很熟悉,非線程安全的容器被非法修改了,具體什麼原因呢,怎麼避免呢,本文簡單分析一下,這個小問題其實反映了對容器實現理解的不深刻。
首先,本着從源頭找問題的原則,貼一下錯誤代碼:
String str = "test";
Iterator<Map.Entry<String, String>> it = params.entrySet().iterator();
while(it.hasNext()){
Map.Entry<String, String> entry=it.next();
if (str.equals(params.get(entry.getKey()))) {
params.remove(entry.getKey());
}
}
這是一個hashmap的demo,上面可以清晰的看到,在遍歷的過程中,符合條件的記錄需要被刪掉。我們想當然的使用了容器直接remove的方法。這時候得到了java.util.ConcurrentModificationException異常。
定位一下問題,很明顯是出在remove這一行。調查了一下,對於非線程安全的容器,這麼搞是不可以的,爲啥呢,我們先看下Iterator的next()方法:
final class EntryIterator extends HashIterator
implements Iterator<Map.Entry<K,V>> {
public final Map.Entry<K,V> next() { return nextNode(); }
}
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;
}
找到重點了,拋出異常的地方在nextNode比較modCount和expectedModCount的地方。
那再看下mocCount什麼時候增加,增加對象的時候增加很好理解,但是減少的時候的呢,看代碼,以下是HashMap.remove(Object) 的實現方法:
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
tab[index] = node.next;
else
p.next = node.next;
++modCount;//重點在這裏
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
可以看到modCount增加了,但是沒expectedModCount什麼事,自然而然也就不想等了。
那我們再看下iterator自帶的remove方法:
public final void remove() {
Node<K,V> p = current;
if (p == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
current = null;
K key = p.key;
removeNode(hash(key), key, null, false, false);
expectedModCount = modCount;//update expectedModCount
}
這裏就把expectedModCount更新了。那麼對比起來就沒問題了。
所以到這裏,我們就找到原因所在了。找到問題,解決起來就方便了。
那麼簡單說一下解決方案吧:
1.使用iterator的remove,是安全的。從上面的代碼中可以看出來,不再多說。
2.使用線程安全的ConcurrentHashMap或者Collections.synchronizedMap(Map<k,v>)
問題解決了,舉一反三的來看,對於其他非線程安全的list,set,map也都使用了fail-fast,也都會有這個問題。使用的時候需要注意了。