欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

由ArrayList來深入理解Java中的fail-fast機制

 更新時間:2016年05月18日 09:00:01   作者:pastqing  
fail-fast俗稱快速失敗,是在多線程進行迭代操作時產(chǎn)生沖突的一種異常拋出機制,下面我們就由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)文章

  • 簡單講解Java的Future編程模式

    簡單講解Java的Future編程模式

    這篇文章主要介紹了Java的Future編程模式,包括對異步和并發(fā)的一些設(shè)計思維,需要的朋友可以參考下
    2015-11-11
  • Java服務(wù)端如何解決跨域問題?CORS請求頭方式

    Java服務(wù)端如何解決跨域問題?CORS請求頭方式

    這篇文章主要介紹了Java服務(wù)端如何解決跨域問題?CORS請求頭方式,具有很好的參考價值,希望對大家有所幫助。如有錯誤或未考慮完全的地方,望不吝賜教
    2022-11-11
  • 詳談jvm線程??臻g內(nèi)存分配位置

    詳談jvm線程??臻g內(nèi)存分配位置

    這篇文章主要介紹了jvm線程??臻g內(nèi)存分配位置,具有很好的參考價值,希望對大家有所幫助。如有錯誤或未考慮完全的地方,望不吝賜教
    2021-09-09
  • 通過openOffice將office文件轉(zhuǎn)成pdf

    通過openOffice將office文件轉(zhuǎn)成pdf

    這篇文章主要介紹了通過openOffice將office文件轉(zhuǎn)成pdf,文中通過示例代碼介紹的非常詳細,對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下
    2020-11-11
  • Redis分布式鎖介紹與使用

    Redis分布式鎖介紹與使用

    服務(wù)器集群項目中的鎖是無法精準的鎖住線程資源的,于是我們就是需要使用分布式鎖,分布式鎖該如何使用又有什么注意點呢?就讓我們進入接下來的學(xué)習(xí)
    2022-09-09
  • netty中pipeline異常事件分析

    netty中pipeline異常事件分析

    這篇文章主要為大家介紹了netty中pipeline異常事件分析,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪
    2023-04-04
  • Java統(tǒng)計字符串中字符出現(xiàn)次數(shù)的方法示例

    Java統(tǒng)計字符串中字符出現(xiàn)次數(shù)的方法示例

    這篇文章主要介紹了Java統(tǒng)計字符串中字符出現(xiàn)次數(shù)的方法,涉及Java針對字符串的遍歷、查找、計算等相關(guān)操作技巧,需要的朋友可以參考下
    2017-12-12
  • 里氏代換原則_動力節(jié)點Java學(xué)院整理

    里氏代換原則_動力節(jié)點Java學(xué)院整理

    這篇文章主要為大家詳細介紹了里氏代換原則的相關(guān)資料,具有一定的參考價值,感興趣的小伙伴們可以參考一下
    2017-08-08
  • Java 匯編JVM編寫jasmin程序的操作方法

    Java 匯編JVM編寫jasmin程序的操作方法

    這篇文章主要介紹了Java 匯編JVM編寫jasmin程序的操作方法,本文通過幾個示例講解的非常詳細,對大家的學(xué)習(xí)或工作具有一定的參考借鑒價值,需要的朋友可以參考下
    2021-04-04
  • 詳解什么是Java線程池的拒絕策略?

    詳解什么是Java線程池的拒絕策略?

    今天給大家總結(jié)一下線程池的拒絕策略,文中有非常詳細的介紹及代碼示例,對正在學(xué)習(xí)java的小伙伴們有很好地幫助,需要的朋友可以參考下
    2021-05-05

最新評論