快速失敗機制（fail-fast）

阿新 • • 發佈：2021-07-01

先了解一些詞語

volatile：volatile的本意是“易變的”。volatile關鍵字是一種型別修飾符，用它宣告的型別變量表示可以被某些編譯器未知的因素更改，比如：作業系統、硬體或者其它執行緒等。遇到這個關鍵字宣告的變數，編譯器對訪問該變數的程式碼就不再進行優化，從而可以提供對特殊地址的穩定訪問。當要求使用volatile 宣告的變數的值的時候，系統總是重新從它所在的記憶體讀取資料，即使它前面的指令剛剛從該處讀取過資料。而且讀取的資料立刻被儲存。volatile 指出 i是隨時可能發生變化的，每次使用它的時候必須從i的地址中讀取。對於volatile型別的變數，系統每次用到他的時候都是直接從對應的記憶體當中提取，而不會利用cache當中的原有數值，以適應它的未知何時會發生的變化。

fail-fast 機制是java集合(Collection)中的一種錯誤機制。當多個執行緒對同一個集合的內容進行操作時，就可能會產生fail-fast事件。
例如：當某一個執行緒A通過iterator去遍歷某集合的過程中，若該集合的內容被其他執行緒所改變了；那麼執行緒A訪問集合時，就會丟擲ConcurrentModificationException異常，產生fail-fast事件。在詳細介紹fail-fast機制的原理之前，先通過一個示例來認識fail-fast。

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&lt;String&gt; list = new ArrayList&lt;String&gt;();



(02) 使用時CopyOnWriteArrayList，不會產生fast-fail事件；定義如下：


       private static List&lt;String&gt; list = new CopyOnWriteArrayList&lt;String&gt;();




@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) {
 </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 同時啟動兩個執行緒對list進行操作！</span>
 <span style="color: rgba(0, 0, 255, 1)">new</span><span style="color: rgba(0, 0, 0, 1)"> ThreadOne().start();
 </span><span style="color: rgba(0, 0, 255, 1)">new</span><span style="color: rgba(0, 0, 0, 1)"> ThreadTwo().start();

}
private static void printAll() {

System.out.println("");
 String value </span>= <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">;
 Iterator iter </span>=<span style="color: rgba(0, 0, 0, 1)"> list.iterator();
 </span><span style="color: rgba(0, 0, 255, 1)">while</span><span style="color: rgba(0, 0, 0, 1)">(iter.hasNext()) {
     value </span>=<span style="color: rgba(0, 0, 0, 1)"> (String)iter.next();
     System.out.print(value</span>+", "<span style="color: rgba(0, 0, 0, 1)">);
 }

}
/**

向list中依次新增0,1,2,3,4,5，每新增一個數之後，就通過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，每新增一個數之後，就通過printAll()遍歷整個list

*/

private static class ThreadTwo extends Thread {

public void run() {

int i = 10;

while (i<16) {

list.add(String.valueOf(i));

printAll();

i++;

}

}

}



}

View Code

執行結果：
執行該程式碼，丟擲異常java.util.ConcurrentModificationException！即，產生fail-fast事件！

結果說明：
(01) FastFailTest中通過 new ThreadOne().start() 和 new ThreadTwo().start() 同時啟動兩個執行緒去操作list。
ThreadOne執行緒：向list中依次新增0,1,2,3,4,5。每新增一個數之後，就通過printAll()遍歷整個list。
ThreadTwo執行緒：向list中依次新增10,11,12,13,14,15。每新增一個數之後，就通過printAll()遍歷整個list。
(02) 當某一個執行緒遍歷list的過程中，list的內容被另外一個執行緒所改變了；就會丟擲ConcurrentModificationException異常，產生fail-fast事件。

fail-fast解決辦法

fail-fast機制，是一種錯誤檢測機制。它只能被用來檢測錯誤，因為JDK並不保證fail-fast機制一定會發生。若在多執行緒環境下使用fail-fast機制的集合，建議使用“java.util.concurrent包下的類”去取代“java.util包下的類”。
所以，本例中只需要將ArrayList替換成java.util.concurrent包下對應的類即可。

fail-fast原理

產生fail-fast事件，是通過丟擲ConcurrentModificationException異常來觸發的。
那麼，ArrayList是如何丟擲ConcurrentModificationException異常的呢?

我們知道，ConcurrentModificationException是在操作Iterator時丟擲的異常。我們先看看Iterator的原始碼。ArrayList的Iterator是在父類AbstractList.java中實現的。程式碼如下：

package java.util;
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
...

</span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> AbstractList中唯一的屬性
</span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 用來記錄List修改的次數：每修改一次(新增/刪除等操作)，將modCount+1</span>
<span style="color: rgba(0, 0, 255, 1)">protected</span> <span style="color: rgba(0, 0, 255, 1)">transient</span> <span style="color: rgba(0, 0, 255, 1)">int</span> modCount = 0<span style="color: rgba(0, 0, 0, 1)">;

</span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 返回List對應迭代器。實際上，是返回Itr物件。</span>
<span style="color: rgba(0, 0, 255, 1)">public</span> Iterator&lt;E&gt;<span style="color: rgba(0, 0, 0, 1)"> iterator() {
    </span><span style="color: rgba(0, 0, 255, 1)">return</span> <span style="color: rgba(0, 0, 255, 1)">new</span><span style="color: rgba(0, 0, 0, 1)"> Itr();
}

</span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> Itr是Iterator(迭代器)的實現類</span>
<span style="color: rgba(0, 0, 255, 1)">private</span> <span style="color: rgba(0, 0, 255, 1)">class</span> Itr <span style="color: rgba(0, 0, 255, 1)">implements</span> Iterator&lt;E&gt;<span style="color: rgba(0, 0, 0, 1)"> {
    </span><span style="color: rgba(0, 0, 255, 1)">int</span> cursor = 0<span style="color: rgba(0, 0, 0, 1)">;

    </span><span style="color: rgba(0, 0, 255, 1)">int</span> lastRet = -1<span style="color: rgba(0, 0, 0, 1)">;

    </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 修改數的記錄值。
    </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 每次新建Itr()物件時，都會儲存新建該物件時對應的modCount；
    </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 以後每次遍歷List中的元素的時候，都會比較expectedModCount和modCount是否相等；
    </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 若不相等，則丟擲ConcurrentModificationException異常，產生fail-fast事件。</span>
    <span style="color: rgba(0, 0, 255, 1)">int</span> expectedModCount =<span style="color: rgba(0, 0, 0, 1)"> modCount;

    </span><span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">boolean</span><span style="color: rgba(0, 0, 0, 1)"> hasNext() {
        </span><span style="color: rgba(0, 0, 255, 1)">return</span> cursor !=<span style="color: rgba(0, 0, 0, 1)"> size();
    }

    </span><span style="color: rgba(0, 0, 255, 1)">public</span><span style="color: rgba(0, 0, 0, 1)"> E next() {
        </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 獲取下一個元素之前，都會判斷“新建Itr物件時儲存的modCount”和“當前的modCount”是否相等；
        </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 若不相等，則丟擲ConcurrentModificationException異常，產生fail-fast事件。</span>

            checkForComodification();

try {

E next = get(cursor);

lastRet = cursor++;

return next;

} catch (IndexOutOfBoundsException e) {

checkForComodification();

throw new NoSuchElementException();

}

}
    </span><span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">void</span><span style="color: rgba(0, 0, 0, 1)"> remove() {
        </span><span style="color: rgba(0, 0, 255, 1)">if</span> (lastRet == -1<span style="color: rgba(0, 0, 0, 1)">)
            </span><span style="color: rgba(0, 0, 255, 1)">throw</span> <span style="color: rgba(0, 0, 255, 1)">new</span><span style="color: rgba(0, 0, 0, 1)"> IllegalStateException();
        checkForComodification();

        </span><span style="color: rgba(0, 0, 255, 1)">try</span><span style="color: rgba(0, 0, 0, 1)"> {
            AbstractList.</span><span style="color: rgba(0, 0, 255, 1)">this</span><span style="color: rgba(0, 0, 0, 1)">.remove(lastRet);
            </span><span style="color: rgba(0, 0, 255, 1)">if</span> (lastRet &lt;<span style="color: rgba(0, 0, 0, 1)"> cursor)
                cursor</span>--<span style="color: rgba(0, 0, 0, 1)">;
            lastRet </span>= -1<span style="color: rgba(0, 0, 0, 1)">;
            expectedModCount </span>=<span style="color: rgba(0, 0, 0, 1)"> modCount;
        } </span><span style="color: rgba(0, 0, 255, 1)">catch</span><span style="color: rgba(0, 0, 0, 1)"> (IndexOutOfBoundsException e) {
            </span><span style="color: rgba(0, 0, 255, 1)">throw</span> <span style="color: rgba(0, 0, 255, 1)">new</span><span style="color: rgba(0, 0, 0, 1)"> ConcurrentModificationException();
        }
    }

    </span><span style="color: rgba(0, 0, 255, 1)">final</span> <span style="color: rgba(0, 0, 255, 1)">void</span><span style="color: rgba(0, 0, 0, 1)"> checkForComodification() {
        </span><span style="color: rgba(0, 0, 255, 1)">if</span> (modCount !=<span style="color: rgba(0, 0, 0, 1)"> expectedModCount)
            </span><span style="color: rgba(0, 0, 255, 1)">throw</span> <span style="color: rgba(0, 0, 255, 1)">new</span><span style="color: rgba(0, 0, 0, 1)"> ConcurrentModificationException();
    }
}

...

}

View Code

從中，我們可以發現在呼叫 next() 和 remove()時，都會執行 checkForComodification()。若 “modCount 不等於 expectedModCount”，則丟擲ConcurrentModificationException異常，產生fail-fast事件。

要搞明白 fail-fast機制，我們就要需要理解什麼時候“modCount 不等於 expectedModCount”！
從Itr類中，我們知道 expectedModCount 在建立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

{
...

</span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> list中容量變化時，對應的同步函式</span>
<span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">void</span> ensureCapacity(<span style="color: rgba(0, 0, 255, 1)">int</span><span style="color: rgba(0, 0, 0, 1)"> minCapacity) {
    modCount</span>++<span style="color: rgba(0, 0, 0, 1)">;
    </span><span style="color: rgba(0, 0, 255, 1)">int</span> oldCapacity =<span style="color: rgba(0, 0, 0, 1)"> elementData.length;
    </span><span style="color: rgba(0, 0, 255, 1)">if</span> (minCapacity &gt;<span style="color: rgba(0, 0, 0, 1)"> oldCapacity) {
        Object oldData[] </span>=<span style="color: rgba(0, 0, 0, 1)"> elementData;
        </span><span style="color: rgba(0, 0, 255, 1)">int</span> newCapacity = (oldCapacity * 3)/2 + 1<span style="color: rgba(0, 0, 0, 1)">;
        </span><span style="color: rgba(0, 0, 255, 1)">if</span> (newCapacity &lt;<span style="color: rgba(0, 0, 0, 1)"> minCapacity)
            newCapacity </span>=<span style="color: rgba(0, 0, 0, 1)"> minCapacity;
        </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> minCapacity is usually close to size, so this is a win:</span>
        elementData =<span style="color: rgba(0, 0, 0, 1)"> Arrays.copyOf(elementData, newCapacity);
    }
}


</span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 新增元素到佇列最後</span>
<span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">boolean</span><span style="color: rgba(0, 0, 0, 1)"> add(E e) {
    </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 修改modCount</span>
    ensureCapacity(size + 1);  <span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> Increments modCount!!</span>
    elementData[size++] =<span style="color: rgba(0, 0, 0, 1)"> e;
    </span><span style="color: rgba(0, 0, 255, 1)">return</span> <span style="color: rgba(0, 0, 255, 1)">true</span><span style="color: rgba(0, 0, 0, 1)">;
}


</span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 新增元素到指定的位置</span>
<span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">void</span> add(<span style="color: rgba(0, 0, 255, 1)">int</span><span style="color: rgba(0, 0, 0, 1)"> index, E element) {
    </span><span style="color: rgba(0, 0, 255, 1)">if</span> (index &gt; size || index &lt; 0<span style="color: rgba(0, 0, 0, 1)">)
        </span><span style="color: rgba(0, 0, 255, 1)">throw</span> <span style="color: rgba(0, 0, 255, 1)">new</span><span style="color: rgba(0, 0, 0, 1)"> IndexOutOfBoundsException(
        </span>"Index: "+index+", Size: "+<span style="color: rgba(0, 0, 0, 1)">size);

    </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 修改modCount</span>
    ensureCapacity(size+1);  <span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> Increments modCount!!</span>
    System.arraycopy(elementData, index, elementData, index + 1<span style="color: rgba(0, 0, 0, 1)">,
         size </span>-<span style="color: rgba(0, 0, 0, 1)"> index);
    elementData[index] </span>=<span style="color: rgba(0, 0, 0, 1)"> element;
    size</span>++<span style="color: rgba(0, 0, 0, 1)">;
}

</span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 新增集合</span>
<span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">boolean</span> addAll(Collection&lt;? <span style="color: rgba(0, 0, 255, 1)">extends</span> E&gt;<span style="color: rgba(0, 0, 0, 1)"> c) {
    Object[] a </span>=<span style="color: rgba(0, 0, 0, 1)"> c.toArray();
    </span><span style="color: rgba(0, 0, 255, 1)">int</span> numNew =<span style="color: rgba(0, 0, 0, 1)"> a.length;
    </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 修改modCount</span>
    ensureCapacity(size + numNew);  <span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> Increments modCount</span>
    System.arraycopy(a, 0<span style="color: rgba(0, 0, 0, 1)">, elementData, size, numNew);
    size </span>+=<span style="color: rgba(0, 0, 0, 1)"> numNew;
    </span><span style="color: rgba(0, 0, 255, 1)">return</span> numNew != 0<span style="color: rgba(0, 0, 0, 1)">;
}


</span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 刪除指定位置的元素 </span>
<span style="color: rgba(0, 0, 255, 1)">public</span> E remove(<span style="color: rgba(0, 0, 255, 1)">int</span><span style="color: rgba(0, 0, 0, 1)"> index) {
    RangeCheck(index);

    </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 修改modCount</span>
    modCount++<span style="color: rgba(0, 0, 0, 1)">;
    E oldValue </span>=<span style="color: rgba(0, 0, 0, 1)"> (E) elementData[index];

    </span><span style="color: rgba(0, 0, 255, 1)">int</span> numMoved = size - index - 1<span style="color: rgba(0, 0, 0, 1)">;
    </span><span style="color: rgba(0, 0, 255, 1)">if</span> (numMoved &gt; 0<span style="color: rgba(0, 0, 0, 1)">)
        System.arraycopy(elementData, index</span>+1<span style="color: rgba(0, 0, 0, 1)">, elementData, index, numMoved);
    elementData[</span>--size] = <span style="color: rgba(0, 0, 255, 1)">null</span>; <span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> Let gc do its work</span>

    <span style="color: rgba(0, 0, 255, 1)">return</span><span style="color: rgba(0, 0, 0, 1)"> oldValue;
}


</span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 快速刪除指定位置的元素 </span>
<span style="color: rgba(0, 0, 255, 1)">private</span> <span style="color: rgba(0, 0, 255, 1)">void</span> fastRemove(<span style="color: rgba(0, 0, 255, 1)">int</span><span style="color: rgba(0, 0, 0, 1)"> index) {

    </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 修改modCount</span>
    modCount++<span style="color: rgba(0, 0, 0, 1)">;
    </span><span style="color: rgba(0, 0, 255, 1)">int</span> numMoved = size - index - 1<span style="color: rgba(0, 0, 0, 1)">;
    </span><span style="color: rgba(0, 0, 255, 1)">if</span> (numMoved &gt; 0<span style="color: rgba(0, 0, 0, 1)">)
        System.arraycopy(elementData, index</span>+1<span style="color: rgba(0, 0, 0, 1)">, elementData, index,
                         numMoved);
    elementData[</span>--size] = <span style="color: rgba(0, 0, 255, 1)">null</span>; <span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> Let gc do its work</span>

    }
</span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 清空集合</span>
<span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">void</span><span style="color: rgba(0, 0, 0, 1)"> clear() {
    </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 修改modCount</span>
    modCount++<span style="color: rgba(0, 0, 0, 1)">;

    </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> Let gc do its work</span>
    <span style="color: rgba(0, 0, 255, 1)">for</span> (<span style="color: rgba(0, 0, 255, 1)">int</span> i = 0; i &lt; size; i++<span style="color: rgba(0, 0, 0, 1)">)
        elementData[i] </span>= <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">;

    size </span>= 0<span style="color: rgba(0, 0, 0, 1)">;
}

...

}

View Code

從中，我們發現：無論是add()、remove()，還是clear()，只要涉及到修改集合中的元素個數時，都會改變modCount的值。

接下來，我們再系統的梳理一下fail-fast是怎麼產生的。步驟如下：
(01)新建了一個ArrayList，名稱為arrayList。
(02)向arrayList中新增內容。
(03)新建一個“執行緒a”，並在“執行緒a”中通過Iterator反覆的讀取arrayList的值。
(04)新建一個“執行緒b”，在“執行緒b”中刪除arrayList中的一個“節點A”。
(05) 這時，就會產生有趣的事件了。
在某一時刻，“執行緒a”建立了arrayList的Iterator。此時“節點A”仍然存在於arrayList中，建立arrayList時，expectedModCount = modCount(假設它們此時的值為N)。
在“執行緒a”在遍歷arrayList過程中的某一時刻，“執行緒b”執行了，並且“執行緒b”刪除了arrayList中的“節點A”。“執行緒b”執行remove()進行刪除操作時，在remove()中執行了“modCount++”，此時modCount變成了N+1！
“執行緒a”接著遍歷，當它執行到next()函式時，呼叫checkForComodification()比較“expectedModCount”和“modCount”的大小；而“expectedModCount=N”，“modCount=N+1”,這樣，便丟擲ConcurrentModificationException異常，產生fail-fast事件。

至此，我們就完全瞭解了fail-fast是如何產生的！
即，當多個執行緒對同一個集合進行操作的時候，某執行緒訪問集合的過程中，該集合的內容被其他執行緒所改變(即其它執行緒通過add、remove、clear等方法，改變了modCount的值)；這時，就會丟擲ConcurrentModificationException異常，產生fail-fast事件。

上面，說明了“解決fail-fast機制的辦法”，也知道了“fail-fast產生的根本原因”。接下來，聊聊併發-Java中的Copy-On-Write容器

Copy-On-Write簡稱COW，是一種用於程式設計中的優化策略。其基本思路是，從一開始大家都在共享同一個內容，當某個人想要修改這個內容的時候，才會真正把內容Copy出去形成一個新的內容然後再改，這是一種延時懶惰策略。從JDK1.5開始Java併發包裡提供了兩個使用CopyOnWrite機制實現的併發容器,它們是CopyOnWriteArrayList和CopyOnWriteArraySet。CopyOnWrite容器非常有用，可以在非常多的併發場景中使用到。

什麼是CopyOnWrite容器

CopyOnWrite容器即寫時複製的容器。通俗的理解是當我們往一個容器新增元素的時候，不直接往當前容器新增，而是先將當前容器進行Copy，複製出一個新的容器，然後新的容器裡新增元素，新增完元素之後，再將原容器的引用指向新的容器。這樣做的好處是我們可以對CopyOnWrite容器進行併發的讀，而不需要加鎖，因為當前容器不會新增任何元素。所以CopyOnWrite容器也是一種讀寫分離的思想，讀和寫不同的容器。

CopyOnWriteArrayList的實現原理

在使用CopyOnWriteArrayList之前，我們先閱讀其原始碼瞭解下它是如何實現的。以下程式碼是向ArrayList裡新增元素，可以發現在新增的時候是需要加鎖的，否則多執行緒寫的時候會Copy出N個副本出來

public boolean add(T e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
    Object[] elements </span>=<span style="color: rgba(0, 0, 0, 1)"> getArray();

    </span><span style="color: rgba(0, 0, 255, 1)">int</span> len =<span style="color: rgba(0, 0, 0, 1)"> elements.length;
    </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 複製出新陣列</span>


        Object[] newElements = Arrays.copyOf(elements, len + 1);
        // 把新元素新增到新數組裡

        newElements[len] = e;
        // 把原陣列引用指向新陣列

        setArray(newElements);
    </span><span style="color: rgba(0, 0, 255, 1)">return</span> <span style="color: rgba(0, 0, 255, 1)">true</span><span style="color: rgba(0, 0, 0, 1)">;

} </span><span style="color: rgba(0, 0, 255, 1)">finally</span><span style="color: rgba(0, 0, 0, 1)"> {

    lock.unlock();

}

}
final void setArray(Object[] a) {

array = a;

}

View Code

讀的時候不需要加鎖，如果讀的時候有多個執行緒正在向ArrayList新增資料，讀還是會讀到舊的資料，因為寫的時候不會鎖住舊的ArrayList。

public E get(int index) {
    return get(getArray(), index);
}

CopyOnWrite的應用場景

CopyOnWrite併發容器用於讀多寫少的併發場景。比如白名單，黑名單，商品類目的訪問和更新場景，假如我們有一個搜尋網站，使用者在這個網站的搜尋框中，輸入關鍵字搜尋內容，但是某些關鍵字不允許被搜尋。這些不能被搜尋的關鍵字會被放在一個黑名單當中，黑名單每天晚上更新一次。當用戶搜尋時，會檢查當前關鍵字在不在黑名單當中，如果在，則提示不能搜尋。實現程式碼如下：

package com.ifeve.book;
import java.util.Map;
import com.ifeve.book.forkjoin.CopyOnWriteMap;
/**

黑名單服務

@author fangtengfei


*/

public class BlackListServiceImpl {
</span><span style="color: rgba(0, 0, 255, 1)">private</span> <span style="color: rgba(0, 0, 255, 1)">static</span> CopyOnWriteMap&lt;String, Boolean&gt; blackListMap = <span style="color: rgba(0, 0, 255, 1)">new</span> CopyOnWriteMap&lt;String, Boolean&gt;<span style="color: rgba(0, 0, 0, 1)">(
        </span>1000<span style="color: rgba(0, 0, 0, 1)">);

</span><span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">static</span> <span style="color: rgba(0, 0, 255, 1)">boolean</span><span style="color: rgba(0, 0, 0, 1)"> isBlackList(String id) {
    </span><span style="color: rgba(0, 0, 255, 1)">return</span> blackListMap.get(id) == <span style="color: rgba(0, 0, 255, 1)">null</span> ? <span style="color: rgba(0, 0, 255, 1)">false</span> : <span style="color: rgba(0, 0, 255, 1)">true</span><span style="color: rgba(0, 0, 0, 1)">;
}

</span><span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">static</span> <span style="color: rgba(0, 0, 255, 1)">void</span><span style="color: rgba(0, 0, 0, 1)"> addBlackList(String id) {
    blackListMap.put(id, Boolean.TRUE);
}

</span><span style="color: rgba(0, 128, 0, 1)">/**</span><span style="color: rgba(0, 128, 0, 1)">
 * 批量新增黑名單
 *
 * </span><span style="color: rgba(128, 128, 128, 1)">@param</span><span style="color: rgba(0, 128, 0, 1)"> ids
 </span><span style="color: rgba(0, 128, 0, 1)">*/</span>
<span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">static</span> <span style="color: rgba(0, 0, 255, 1)">void</span> addBlackList(Map&lt;String,Boolean&gt;<span style="color: rgba(0, 0, 0, 1)"> ids) {
    blackListMap.putAll(ids);
}

}

View Code

程式碼很簡單，但是使用CopyOnWriteMap需要注意兩件事情：

1. 減少擴容開銷。根據實際需要，初始化CopyOnWriteMap的大小，避免寫時CopyOnWriteMap擴容的開銷。

2. 使用批量新增。因為每次新增，容器每次都會進行復制，所以減少新增次數，可以減少容器的複製次數。如使用上面程式碼裡的addBlackList方法。

CopyOnWrite的缺點

CopyOnWrite容器有很多優點，但是同時也存在兩個問題，即記憶體佔用問題和資料一致性問題。所以在開發的時候需要注意一下。

記憶體佔用問題。因為CopyOnWrite的寫時複製機制，所以在進行寫操作的時候，記憶體裡會同時駐紮兩個物件的記憶體，舊的物件和新寫入的物件（注意:在複製的時候只是複製容器裡的引用，只是在寫的時候會建立新物件新增到新容器裡，而舊容器的物件還在使用，所以有兩份物件記憶體）。如果這些物件佔用的記憶體比較大，比如說200M左右，那麼再寫入100M資料進去，記憶體就會佔用300M，那麼這個時候很有可能造成頻繁的Yong GC和Full GC。之前我們系統中使用了一個服務由於每晚使用CopyOnWrite機制更新大物件，造成了每晚15秒的Full GC，應用響應時間也隨之變長。頻繁的GC是因為修改CopyOnWriteArrayList裡大量的元素造成的。兩份物件記憶體是指修改前和修改後兩個元素記憶體。

針對記憶體佔用問題，可以通過壓縮容器中的元素的方法來減少大物件的記憶體消耗，比如，如果元素全是10進位制的數字，可以考慮把它壓縮成36進位制或64進位制。或者不使用CopyOnWrite容器，而使用其他的併發容器，如ConcurrentHashMap。

資料一致性問題。CopyOnWrite容器只能保證資料的最終一致性，不能保證資料的實時一致性。所以如果你希望寫入的的資料，馬上能讀到，請不要使用CopyOnWrite容器。

安全失敗：

採用安全失敗機制的集合容器，在遍歷時不是直接在集合內容上訪問的，而是先複製原有集合內容，在拷貝的集合上進行遍歷。

由於迭代時是對原集合的拷貝進行遍歷，所以在遍歷過程中對原集合所作的修改並不能被迭代器檢測到，故不會拋 ConcurrentModificationException 異常。

引用自：https://www.cnblogs.com/ccgjava/p/6347425.html?utm_source=itdadao&utm_medium=referral

https://blog.csdn.net/a549654065/article/details/105624519

快速失敗機制（fail-fast）

先了解一些詞語 volatile：volatile的本意是“易變的”。volatile關鍵字是一種型別修飾符，用它宣告的型別變量表示可以被某些編譯器未知的因素更改，比如：作業系統、硬體或者其它執行緒等。遇到這個關鍵字宣告的變

淺析Java對集合進行操作時報java.util.ConcurrentModificationException併發修改異常問題：產生原因、單執行緒/多執行緒環境解決、CopyOnWriteArrayList執行緒安全的ArrayList、fail-fast快速失敗機制防止多執行緒修改集合造成併發問題

一、異常產生　　當我們迭代一個ArrayList或者HashMap時，如果嘗試對集合做一些修改操作（例如刪除元素），可能會丟擲java.util.ConcurrentModificationException的異常。

快速失敗機制（fail-fast）

fail-fast解決辦法

fail-fast原理

什麼是CopyOnWrite容器

CopyOnWriteArrayList的實現原理

CopyOnWrite的應用場景

CopyOnWrite的缺點

快速失敗機制（fail-fast）

淺析Java對集合進行操作時報java.util.ConcurrentModificationException併發修改異常問題：產生原因、單執行緒/多執行緒環境解決、CopyOnWriteArrayList執行緒安全的ArrayList、fail-fast快速失敗機制防止多執行緒修改集合造成併發問題

快速排序實現（快排）

深度解析Python垃圾回收機制（超級詳細）

Spring Boot快速入門之（十一）：構建 RESTful Web 服務

spring cloud微服務快速教程之（十二）分散式ID解決方案（mybatis-plus篇）

spring cloud微服務快速教程之（十四）spring cloud feign使用okhttp3--以及feign呼叫引數丟失的說明

轉載-python垃圾回收機制（Garbage collection）

mysql的表鎖機制（讀寫）

Vue知識點總結(23)——Vue-Cli3腳手架基本配置和快速原型開發（超級詳細）

快速搭建網站（阿里雲）

Python MySQL單條資料快速入庫方法（使用 sqlacodegen）

007Java集合012快速失敗機制和安全失敗機制

【面試普通人VS高手系列】Fail-safe機制與Fail-fast機制分別有什麼作用

linux訊號機制（初識版）

淺析Java的fail-fast（快速失敗）機制、COW優化策略、CopyOnWrite併發容器-讀寫分離思想

Redis持久化機制（AOF和RDB）

SpringBoot啟動機制（starter機制）核心原理詳解

日誌檔案寫入失敗（permission denied）

MySQL資料誤刪除的快速解決方法（MySQL閃回工具）

快速失敗機制（fail-fast）

fail-fast解決辦法

fail-fast原理

什麼是CopyOnWrite容器

CopyOnWriteArrayList的實現原理

CopyOnWrite的應用場景

CopyOnWrite的缺點

相關推薦