Java 集合系列(3): fail-fast总结(通过ArrayList来说明fail-fast的原理、解决办法)...
戳上面的藍字關注我們哦!
?精彩內容?
?
精選java等全套視頻教程
精選java電子圖書
大數(shù)據(jù)視頻教程精選
java項目練習精選
概要
前面,我們已經(jīng)學習了ArrayList。接下來,我們以ArrayList為例,對Iterator的fail-fast機制進行了解。
1 fail-fast簡介
fail-fast 機制是java集合(Collection)中的一種錯誤機制。當多個線程對同一個集合的內容進行操作時,就可能會產生fail-fast事件。
例如:當某一個線程A通過iterator去遍歷某集合的過程中,若該集合的內容被其他線程所改變了;那么線程A訪問集合時,就會拋出ConcurrentModificationException異常,產生fail-fast事件。
在詳細介紹fail-fast機制的原理之前,先通過一個示例來認識fail-fast。
2 fail-fast示例
示例代碼:(FastFailTest.java)
import java.util.*; import java.util.concurrent.*; /** @desc java集合中Fast-Fail的測試程序。** ? fast-fail事件產生的條件:當多個線程對Collection進行操作時,若其中某一個線程通過iterator去遍歷集合時,該集合的內容被其他線程所改變;則會拋出ConcurrentModificationException異常。* ? fast-fail解決辦法:通過util.concurrent集合包下的相應類去處理,則不會產生fast-fail事件。** ? 本例中,分別測試ArrayList和CopyOnWriteArrayList這兩種情況。ArrayList會產生fast-fail事件,而CopyOnWriteArrayList不會產生fast-fail事件。* ? (01) 使用ArrayList時,會產生fast-fail事件,拋出ConcurrentModificationException異常;定義如下:* ? ? ? ? ? ?private static List<String> list = new ArrayList<String>();* ? (02) 使用時CopyOnWriteArrayList,不會產生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++;}}} }運行結果:
運行該代碼,拋出異常java.util.ConcurrentModificationException!即,產生fail-fast事件!
結果說明:
(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的內容被另外一個線程所改變了;就會拋出ConcurrentModificationException異常,產生fail-fast事件。
3 fail-fast解決辦法
fail-fast機制,是一種錯誤檢測機制。它只能被用來檢測錯誤,因為JDK并不保證fail-fast機制一定會發(fā)生。若在多線程環(huán)境下使用fail-fast機制的集合,建議使用“java.util.concurrent包下的類”去取代“java.util包下的類”。
所以,本例中只需要將ArrayList替換成java.util.concurrent包下對應的類即可。
即,將代碼
替換為
private static List<String> list = new CopyOnWriteArrayList<String>();則可以解決該辦法。
4 fail-fast原理
產生fail-fast事件,是通過拋出ConcurrentModificationException異常來觸發(fā)的。
那么,ArrayList是如何拋出ConcurrentModificationException異常的呢?
我們知道,ConcurrentModificationException是在操作Iterator時拋出的異常。我們先看看Iterator的源碼。ArrayList的Iterator是在父類AbstractList.java中實現(xiàn)的。代碼如下:
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {...// AbstractList中唯一的屬性// 用來記錄List修改的次數(shù):每修改一次(添加/刪除等操作),將modCount+1protected transient int modCount = 0;// 返回List對應迭代器。實際上,是返回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()對象時,都會保存新建該對象時對應的modCount;// 以后每次遍歷List中的元素的時候,都會比較expectedModCount和modCount是否相等;// 若不相等,則拋出ConcurrentModificationException異常,產生fail-fast事件。int expectedModCount = modCount;public boolean hasNext() {return cursor != size();}public E next() {// 獲取下一個元素之前,都會判斷“新建Itr對象時保存的modCount”和“當前的modCount”是否相等;// 若不相等,則拋出ConcurrentModificationException異常,產生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)在調用 next() 和 remove()時,都會執(zhí)行 checkForComodification()。若 “modCount 不等于 expectedModCount”,則拋出ConcurrentModificationException異常,產生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中容量變化時,對應的同步函數(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) {// 修改modCountensureCapacity(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);// 修改modCountensureCapacity(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;// 修改modCountensureCapacity(size + numNew); ?// Increments modCountSystem.arraycopy(a, 0, elementData, size, numNew);size += numNew;return numNew != 0;}// 刪除指定位置的元素 public E remove(int index) {RangeCheck(index);// 修改modCountmodCount++;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 workreturn oldValue;}// 快速刪除指定位置的元素 private void fastRemove(int index) {// 修改modCountmodCount++;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() {// 修改modCountmodCount++;// Let gc do its workfor (int i = 0; i < size; i++)elementData[i] = null;size = 0;}... }從中,我們發(fā)現(xiàn):無論是add()、remove(),還是clear(),只要涉及到修改集合中的元素個數(shù)時,都會改變modCount的值。
接下來,我們再系統(tǒng)的梳理一下fail-fast是怎么產生的。步驟如下:
(01) 新建了一個ArrayList,名稱為arrayList。
(02) 向arrayList中添加內容。
(03) 新建一個“線程a”,并在“線程a”中通過Iterator反復的讀取arrayList的值。
(04) 新建一個“線程b”,在“線程b”中刪除arrayList中的一個“節(jié)點A”。
(05) 這時,就會產生有趣的事件了。
? ? ? 在某一時刻,“線程a”創(chuàng)建了arrayList的Iterator。此時“節(jié)點A”仍然存在于arrayList中,創(chuàng)建arrayList時,expectedModCount = modCount(假設它們此時的值為N)。
? ? ? 在“線程a”在遍歷arrayList過程中的某一時刻,“線程b”執(zhí)行了,并且“線程b”刪除了arrayList中的“節(jié)點A”。“線程b”執(zhí)行remove()進行刪除操作時,在remove()中執(zhí)行了“modCount++”,此時modCount變成了N+1!
“線程a”接著遍歷,當它執(zhí)行到next()函數(shù)時,調用checkForComodification()比較“expectedModCount”和“modCount”的大小;而“expectedModCount=N”,“modCount=N+1”,這樣,便拋出ConcurrentModificationException異常,產生fail-fast事件。
至此,我們就完全了解了fail-fast是如何產生的!
即,當多個線程對同一個集合進行操作的時候,某線程訪問集合的過程中,該集合的內容被其他線程所改變(即其它線程通過add、remove、clear等方法,改變了modCount的值);這時,就會拋出ConcurrentModificationException異常,產生fail-fast事件。
5 解決fail-fast的原理
上面,說明了“解決fail-fast機制的辦法”,也知道了“fail-fast產生的根本原因”。接下來,我們再進一步談談java.util.concurrent包中是如何解決fail-fast事件的。
還是以和ArrayList對應的CopyOnWriteArrayList進行說明。我們先看看CopyOnWriteArrayList的源碼:
從中,我們可以看出:
(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)類中調用next()時,會“調用checkForComodification()比較‘expectedModCount’和‘modCount’的大小”;但是,CopyOnWriteArrayList的Iterator實現(xiàn)類中,沒有所謂的checkForComodification(),更不會拋出ConcurrentModificationException異常!
出處:http://www.cnblogs.com/skywang12345/p/3308762.html
回復以下關鍵字獲取更多學習資源
java基礎|html5|css|js|jquery|angularJs|ajax|node.js|javaEE基礎| |struts2|hibernate|spring|svn|maven|springmvc|mybatis|linux|oracle| |luncene|solr|redis|springboot|架構師資源|dubbo|php|webservice|c++基礎|nginx|mysql|sqlserver|asp.net|大數(shù)據(jù)|java項目
更多學習資源逐步更新,請置頂公眾號不要錯過更新
好好學java
每日推送java優(yōu)質文章、視頻教程、熱點資訊
微信ID:sihailoveyan
長按左側二維碼關注
總結
以上是生活随笔為你收集整理的Java 集合系列(3): fail-fast总结(通过ArrayList来说明fail-fast的原理、解决办法)...的全部內容,希望文章能夠幫你解決所遇到的問題。
- 上一篇: Java 集合系列(2): ArrayL
- 下一篇: Java 集合系列(4): Linked