由ArrayList來深入理解Java中的fail-fast機制
1. fail-fast簡介
“快速失敗”也就是fail-fast,它是Java集合的一種錯誤檢測機制。某個線程在對collection進行迭代時,不允許其他線程對該collection進行結(jié)構(gòu)上的修改。
例如:假設(shè)存在兩個線程(線程1、線程2),線程1通過Iterator在遍歷集合A中的元素,在某個時候線程2修改了集合A的結(jié)構(gòu)(是結(jié)構(gòu)上面的修改,而不是簡單的修改集合元素的內(nèi)容),那么這個時候程序就會拋出 ConcurrentModificationException 異常,從而產(chǎn)生fail-fast。
迭代器的快速失敗行為無法得到保證,它不能保證一定會出現(xiàn)該錯誤,因此,ConcurrentModificationException應(yīng)該僅用于檢測 bug。
Java.util包中的所有集合類都是快速失敗的,而java.util.concurrent包中的集合類都是安全失敗的;
快速失敗的迭代器拋出ConcurrentModificationException,而安全失敗的迭代器從不拋出這個異常。
2 fail-fast示例
示例代碼:(FastFailTest.java)
import java.util.*; import java.util.concurrent.*; /* * @desc java集合中Fast-Fail的測試程序。 * * fast-fail事件產(chǎn)生的條件:當多個線程對Collection進行操作時,若其中某一個線程通過iterator去遍歷集合時,該集合的內(nèi)容被其他線程所改變;則會拋出ConcurrentModificationException異常。 * fast-fail解決辦法:通過util.concurrent集合包下的相應(yīng)類去處理,則不會產(chǎn)生fast-fail事件。 * * 本例中,分別測試ArrayList和CopyOnWriteArrayList這兩種情況。ArrayList會產(chǎn)生fast-fail事件,而CopyOnWriteArrayList不會產(chǎn)生fast-fail事件。 * (01) 使用ArrayList時,會產(chǎn)生fast-fail事件,拋出ConcurrentModificationException異常;定義如下: * private static List<String> list = new ArrayList<String>(); * (02) 使用時CopyOnWriteArrayList,不會產(chǎn)生fast-fail事件;定義如下: * private static List<String> list = new CopyOnWriteArrayList<String>(); * * @author skywang */ public class FastFailTest { private static List<String> list = new ArrayList<String>(); //private static List<String> list = new CopyOnWriteArrayList<String>(); public static void main(String[] args) { // 同時啟動兩個線程對list進行操作! new ThreadOne().start(); new ThreadTwo().start(); } private static void printAll() { System.out.println(""); String value = null; Iterator iter = list.iterator(); while(iter.hasNext()) { value = (String)iter.next(); System.out.print(value+", "); } } /** * 向list中依次添加0,1,2,3,4,5,每添加一個數(shù)之后,就通過printAll()遍歷整個list */ private static class ThreadOne extends Thread { public void run() { int i = 0; while (i<6) { list.add(String.valueOf(i)); printAll(); i++; } } } /** * 向list中依次添加10,11,12,13,14,15,每添加一個數(shù)之后,就通過printAll()遍歷整個list */ private static class ThreadTwo extends Thread { public void run() { int i = 10; while (i<16) { list.add(String.valueOf(i)); printAll(); i++; } } } }
運行結(jié)果
運行該代碼,拋出異常java.util.ConcurrentModificationException!即,產(chǎn)生fail-fast事件!
結(jié)果說明
(01) FastFailTest中通過 new ThreadOne().start() 和 new ThreadTwo().start() 同時啟動兩個線程去操作list。
ThreadOne線程:向list中依次添加0,1,2,3,4,5。每添加一個數(shù)之后,就通過printAll()遍歷整個list。
ThreadTwo線程:向list中依次添加10,11,12,13,14,15。每添加一個數(shù)之后,就通過printAll()遍歷整個list。
(02) 當某一個線程遍歷list的過程中,list的內(nèi)容被另外一個線程所改變了;就會拋出ConcurrentModificationException異常,產(chǎn)生fail-fast事件。
3. fail-fast解決辦法
fail-fast機制,是一種錯誤檢測機制。它只能被用來檢測錯誤,因為JDK并不保證fail-fast機制一定會發(fā)生。若在多線程環(huán)境下使用fail-fast機制的集合,建議使用“java.util.concurrent包下的類”去取代“java.util包下的類”。
所以,本例中只需要將ArrayList替換成java.util.concurrent包下對應(yīng)的類即可。 即,將代碼
private static List<String> list = new ArrayList<String>();
替換為
private static List<String> list = new CopyOnWriteArrayList<String>();
則可以解決該辦法。
4. fail-fast原理
產(chǎn)生fail-fast事件,是通過拋出ConcurrentModificationException異常來觸發(fā)的。
那么,ArrayList是如何拋出ConcurrentModificationException異常的呢?
我們知道,ConcurrentModificationException是在操作Iterator時拋出的異常。我們先看看Iterator的源碼。ArrayList的Iterator是在父類AbstractList.java中實現(xiàn)的。代碼如下:
package java.util;
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> { ... // AbstractList中唯一的屬性 // 用來記錄List修改的次數(shù):每修改一次(添加/刪除等操作),將modCount+1 protected transient int modCount = 0; // 返回List對應(yīng)迭代器。實際上,是返回Itr對象。 public Iterator<E> iterator() { return new Itr(); } // Itr是Iterator(迭代器)的實現(xiàn)類 private class Itr implements Iterator<E> { int cursor = 0; int lastRet = -1; // 修改數(shù)的記錄值。 // 每次新建Itr()對象時,都會保存新建該對象時對應(yīng)的modCount; // 以后每次遍歷List中的元素的時候,都會比較expectedModCount和modCount是否相等; // 若不相等,則拋出ConcurrentModificationException異常,產(chǎn)生fail-fast事件。 int expectedModCount = modCount; public boolean hasNext() { return cursor != size(); } public E next() { // 獲取下一個元素之前,都會判斷“新建Itr對象時保存的modCount”和“當前的modCount”是否相等; // 若不相等,則拋出ConcurrentModificationException異常,產(chǎn)生fail-fast事件。 checkForComodification(); try { E next = get(cursor); lastRet = cursor++; return next; } catch (IndexOutOfBoundsException e) { checkForComodification(); throw new NoSuchElementException(); } } public void remove() { if (lastRet == -1) throw new IllegalStateException(); checkForComodification(); try { AbstractList.this.remove(lastRet); if (lastRet < cursor) cursor--; lastRet = -1; expectedModCount = modCount; } catch (IndexOutOfBoundsException e) { throw new ConcurrentModificationException(); } } final void checkForComodification() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); } } ... }
從中,我們可以發(fā)現(xiàn)在調(diào)用 next() 和 remove()時,都會執(zhí)行 checkForComodification()。若 “modCount 不等于 expectedModCount”,則拋出ConcurrentModificationException異常,產(chǎn)生fail-fast事件。
要搞明白 fail-fast機制,我們就要需要理解什么時候“modCount 不等于 expectedModCount”!
從Itr類中,我們知道 expectedModCount 在創(chuàng)建Itr對象時,被賦值為 modCount。通過Itr,我們知道:expectedModCount不可能被修改為不等于 modCount。所以,需要考證的就是modCount何時會被修改。
接下來,我們查看ArrayList的源碼,來看看modCount是如何被修改的。
package java.util; public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable { ... // list中容量變化時,對應(yīng)的同步函數(shù) public void ensureCapacity(int minCapacity) { modCount++; int oldCapacity = elementData.length; if (minCapacity > oldCapacity) { Object oldData[] = elementData; int newCapacity = (oldCapacity * 3)/2 + 1; if (newCapacity < minCapacity) newCapacity = minCapacity; // minCapacity is usually close to size, so this is a win: elementData = Arrays.copyOf(elementData, newCapacity); } } // 添加元素到隊列最后 public boolean add(E e) { // 修改modCount ensureCapacity(size + 1); // Increments modCount!! elementData[size++] = e; return true; } // 添加元素到指定的位置 public void add(int index, E element) { if (index > size || index < 0) throw new IndexOutOfBoundsException( "Index: "+index+", Size: "+size); // 修改modCount ensureCapacity(size+1); // Increments modCount!! System.arraycopy(elementData, index, elementData, index + 1, size - index); elementData[index] = element; size++; } // 添加集合 public boolean addAll(Collection<? extends E> c) { Object[] a = c.toArray(); int numNew = a.length; // 修改modCount ensureCapacity(size + numNew); // Increments modCount System.arraycopy(a, 0, elementData, size, numNew); size += numNew; return numNew != 0; } // 刪除指定位置的元素 public E remove(int index) { RangeCheck(index); // 修改modCount modCount++; E oldValue = (E) elementData[index]; int numMoved = size - index - 1; if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); elementData[--size] = null; // Let gc do its work return oldValue; } // 快速刪除指定位置的元素 private void fastRemove(int index) { // 修改modCount modCount++; int numMoved = size - index - 1; if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); elementData[--size] = null; // Let gc do its work } // 清空集合 public void clear() { // 修改modCount modCount++; // Let gc do its work for (int i = 0; i < size; i++) elementData[i] = null; size = 0; } ... }
從中,我們發(fā)現(xiàn):無論是add()、remove(),還是clear(),只要涉及到修改集合中的元素個數(shù)時,都會改變modCount的值。
接下來,我們再系統(tǒng)的梳理一下fail-fast是怎么產(chǎn)生的。步驟如下:
(01) 新建了一個ArrayList,名稱為arrayList。
(02) 向arrayList中添加內(nèi)容。
(03) 新建一個“線程a”,并在“線程a”中通過Iterator反復(fù)的讀取arrayList的值。
(04) 新建一個“線程b”,在“線程b”中刪除arrayList中的一個“節(jié)點A”。
(05) 這時,就會產(chǎn)生有趣的事件了。
在某一時刻,“線程a”創(chuàng)建了arrayList的Iterator。此時“節(jié)點A”仍然存在于arrayList中,創(chuàng)建arrayList時,expectedModCount = modCount(假設(shè)它們此時的值為N)。
在“線程a”在遍歷arrayList過程中的某一時刻,“線程b”執(zhí)行了,并且“線程b”刪除了arrayList中的“節(jié)點A”?!熬€程b”執(zhí)行remove()進行刪除操作時,在remove()中執(zhí)行了“modCount++”,此時modCount變成了N+1!
“線程a”接著遍歷,當它執(zhí)行到next()函數(shù)時,調(diào)用checkForComodification()比較“expectedModCount”和“modCount”的大?。欢癳xpectedModCount=N”,“modCount=N+1”,這樣,便拋出ConcurrentModificationException異常,產(chǎn)生fail-fast事件。
至此,我們就完全了解了fail-fast是如何產(chǎn)生的!
即,當多個線程對同一個集合進行操作的時候,某線程訪問集合的過程中,該集合的內(nèi)容被其他線程所改變(即其它線程通過add、remove、clear等方法,改變了modCount的值);這時,就會拋出ConcurrentModificationException異常,產(chǎn)生fail-fast事件。
5. 解決fail-fast的原理
上面,說明了“解決fail-fast機制的辦法”,也知道了“fail-fast產(chǎn)生的根本原因”。接下來,我們再進一步談?wù)刯ava.util.concurrent包中是如何解決fail-fast事件的。
還是以和ArrayList對應(yīng)的CopyOnWriteArrayList進行說明。我們先看看CopyOnWriteArrayList的源碼:
package java.util.concurrent; import java.util.*; import java.util.concurrent.locks.*; import sun.misc.Unsafe; public class CopyOnWriteArrayList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable { ... // 返回集合對應(yīng)的迭代器 public Iterator<E> iterator() { return new集合類中的fast-fail實現(xiàn)方式都差不多,我們以最簡單的ArrayList為例吧。protected transient int modCount = 0;記錄的是我們對ArrayList修改的次數(shù),比如我們調(diào)用 add(),remove()等改變數(shù)據(jù)的操作時,會將modCount++。protected transient int modCount = 0;記錄的是我們對ArrayList修改的次數(shù),比如我們調(diào)用 add(),remove()等改變數(shù)據(jù)的操作時,會將modCount++。 COWIterator<E>(getArray(), 0); } ... private static class COWIterator<E> implements ListIterator<E> { private final Object[] snapshot; private int cursor; private COWIterator(Object[] elements, int initialCursor) { cursor = initialCursor; // 新建COWIterator時,將集合中的元素保存到一個新的拷貝數(shù)組中。 // 這樣,當原始集合的數(shù)據(jù)改變,拷貝數(shù)據(jù)中的值也不會變化。 snapshot = elements; } public boolean hasNext() { return cursor < snapshot.length; } public boolean hasPrevious() { return cursor > 0; } public E next() { if (! hasNext()) throw new NoSuchElementException(); return (E) snapshot[cursor++]; } public E previous() { if (! hasPrevious()) throw new NoSuchElementException(); return (E) snapshot[--cursor]; } public int nextIndex() { return cursor; } public int previousIndex() { return cursor-1; } public void remove() { throw new UnsupportedOperationException(); } public void set(E e) { throw new UnsupportedOperationException(); } public void add(E e) { throw new UnsupportedOperationException(); } } ... }
從中,我們可以看出:
(01) 和ArrayList繼承于AbstractList不同,CopyOnWriteArrayList沒有繼承于AbstractList,它僅僅只是實現(xiàn)了List接口。
(02) ArrayList的iterator()函數(shù)返回的Iterator是在AbstractList中實現(xiàn)的;而CopyOnWriteArrayList是自己實現(xiàn)Iterator。
(03) ArrayList的Iterator實現(xiàn)類中調(diào)用next()時,會“調(diào)用checkForComodification()比較‘expectedModCount'和‘modCount'的大小”;但是,CopyOnWriteArrayList的Iterator實現(xiàn)類中,沒有所謂的checkForComodification(),更不會拋出ConcurrentModificationException異常!
6. 總結(jié)
由于HashMap(ArrayList)并不是線程安全的,因此如果在使用迭代器的過程中有其他線程修改了map(這里的修改是指結(jié)構(gòu)上的修改,并非指單純修改集合內(nèi)容的元素),那么將要拋出ConcurrentModificationException 即為fail-fast策略
主要通過modCount域來實現(xiàn),保證線程之間的可見性,modCount即為修改次數(shù),對于HashMap(ArrayList)內(nèi)容的修改就會增加這個值, 那么在迭代器的初始化過程中就會將這個值賦值給迭代器的expectedModCount
但是fail-fast行為并不能保證,因此依賴于此異常的程序的做法是錯誤的
相關(guān)文章
通過openOffice將office文件轉(zhuǎn)成pdf
這篇文章主要介紹了通過openOffice將office文件轉(zhuǎn)成pdf,文中通過示例代碼介紹的非常詳細,對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下2020-11-11Java統(tǒng)計字符串中字符出現(xiàn)次數(shù)的方法示例
這篇文章主要介紹了Java統(tǒng)計字符串中字符出現(xiàn)次數(shù)的方法,涉及Java針對字符串的遍歷、查找、計算等相關(guān)操作技巧,需要的朋友可以參考下2017-12-12