集合迭代器快速失敗行為及CopyOnWriteArrayList


以下內容基於jdk1.7.0_79源碼;

什么是集合迭代器快速失敗行為

以ArrayList為例,在多線程並發情況下,如果有一個線程在修改ArrayList集合的結構(插入、移除...),而另一個線程正在用迭代器遍歷讀取集合中的元素,此時將拋出ConcurrentModificationException異常立即停止迭代遍歷操作,而不需要等到遍歷結束后再檢查有沒有出現問題;

ArrayList.Itr迭代器快速失敗源碼及例子

查看ArrayList的Itr迭代器源碼,可以看到Itr為ArrayList的私有內部類,有一個expectedModCount成員屬性,在迭代器對象創建的時候初始化為ArrayList的modCount,即當迭代器對象創建的時候,會將集合修改次數modCount存到expectedModCount里,然后每次遍歷取值的時候,都會拿ArrayList集合修改次數modCount與迭代器的expectedModCount比較,如果發生改變,說明集合結構在創建該迭代器后已經發生了改變,直接拋出ConcurrentModificationException異常,如下代碼;

        final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}

先舉一個不是多線程的簡單例子,在創建迭代器后,往ArrayList插入一條數據,然后利用迭代器遍歷,如下代碼,將拋出ConcurrentModificationException異常:

package com.pichen.basis.col;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Main {

public static void main(String[] args) {
List
<Integer> list = new ArrayList<Integer>();
for(int i = 0; i < 10; i++){
list.add(i);
}

Iterator
<Integer> iterator = list.iterator();
list.add(
10);
while(iterator.hasNext()){
iterator.next();
}
}
}
Exception in thread "main" java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:859)
at java.util.ArrayList$Itr.next(ArrayList.java:831)
at com.pichen.basis.col.Main.main(Main.java:18)

再來個多線程的例子,我們創建一個t1線程,循環往集合插入數據,另外主線程獲取集合迭代器遍歷集合,如下代碼,在遍歷的過程中將拋出ConcurrentModificationException異常:

package com.pichen.basis.col;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

class ThreadTest implements Runnable{
private List<Integer> list;
public ThreadTest(List<Integer> list) {
this.list = list;
}
@Override
public void run() {
while(true){
try {
Thread.sleep(
500);
}
catch (InterruptedException e) {
e.printStackTrace();
}
this.list.add(10);
}
}
}
public class Main {
public static void main(String[] args) throws InterruptedException {
List
<Integer> list = new ArrayList<Integer>();
for(int i = 0; i < 10; i++){
list.add(i);
}

ThreadTest t1
= new ThreadTest(list);
new Thread(t1).start();

Iterator
<Integer> iterator = list.iterator();
while(iterator.hasNext()){
System.out.print(iterator.next()
+ " ");
Thread.sleep(
80);
}
}
}

結果打印:

0 1 2 3 4 5 6 Exception in thread "main" java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:859)
at java.util.ArrayList$Itr.next(ArrayList.java:831)
at com.pichen.basis.col.Main.main(Main.java:44)

ConcurrentModificationException異常解決辦法

對ArrayList集合修改次數modCount加鎖或使用CopyOnWriteArrayList替換ArrayList,建議使用CopyOnWriteArrayList;

另外除了List集合外,其它集合像ConcurrentHashMap、CopyOnWriteArraySet也可以避免拋出ConcurrentModificationException異常;

什么是CopyOnWriteArrayList

看名字就知道,在往集合寫操作的時候,復制集合;更具體地說,是在對集合結構進行修改的操作時,復制一個新的集合,然后在新的集合里進行結構修改(插入、刪除),修改完成之后,改變原先集合內部數組的引用為新集合即可;

CopyOnWriteArrayList補充說明

CopyOnWriteArrayList類實現List<E>, RandomAccess, Cloneable, java.io.Serializable接口

與ArrayList功能類似,同樣是基於動態數組實現的集合;

使用CopyOnWriteArrayList迭代器遍歷的時候,讀取的數據並不是實時的;

每次對集合結構進行修改時,都需要拷貝數據,占用內存較大;

源碼查看

先看個簡單的例子,add方法,如下,調用了Arrays.copyOf方法,拷貝舊數組到新數組,然后修改新數組的值,並修改集合內部數組的引用:

    public boolean add(E e) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements
= getArray();
int len = elements.length;
Object[] newElements
= Arrays.copyOf(elements, len + 1);
newElements[len]
= e;
setArray(newElements);
return true;
}
finally {
lock.unlock();
}
}

再查看CopyOnWriteArrayList迭代器類的實現,部分代碼如下, 在創建COWIterator迭代器的時候,仔細查看其構造器源碼,需要將集合內部數組的引用傳給迭代器對象,由於在集合修改的時候,操作都是針對新的拷貝數組,所以迭代器內部舊數組對象不會改變,保證迭代期間數據不會混亂(雖然不是實時的數據):

    private static class COWIterator<E> implements ListIterator<E> {
/** Snapshot of the array */
private final Object[] snapshot;
/** Index of element to be returned by subsequent call to next. */
private int cursor;

private COWIterator(Object[] elements, int initialCursor) {
cursor
= initialCursor;
snapshot
= elements;
}
........

結果驗證

利用前面拋出ConcurrentModificationException的例子,驗證使用CopyOnWriteArrayList,

首先,創建一個t1線程,循環往集合插入數據,另外主線程獲取集合迭代器遍歷集合,代碼如下,成功運行,並打印出了舊集合的數據(注意數據並不是實時的)

package com.pichen.basis.col;

import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

class ThreadTest implements Runnable{

private List<Integer> list;
public ThreadTest(List<Integer> list) {
this.list = list;
}
@Override
public void run() {
while(true){
try {
Thread.sleep(
500);
}
catch (InterruptedException e) {
e.printStackTrace();
}
this.list.add(10);
}
}
}

public class Main {

public static void main(String[] args) throws InterruptedException {

List
<Integer> list = new CopyOnWriteArrayList<Integer>();
for(int i = 0; i < 10; i++){
list.add(i);
}

ThreadTest t1
= new ThreadTest(list);
new Thread(t1).start();

Iterator
<Integer> iterator = list.iterator();
while(iterator.hasNext()){
System.out.print(iterator.next()
+ " ");
Thread.sleep(
80);
}
}
}

 


注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
粤ICP备14056181号  © 2014-2021 ITdaan.com