1、簡介

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

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

2、CopyOnWriteArrayList的實現原理

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

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(); } } 
 

讀的時候不需要加鎖，如果讀的時候有多個執行緒正在向ArrayList新增資料，讀還是會讀到舊的資料，因為寫的時候不會鎖住舊的ArrayList，因為陣列物件是用volatile修飾的，所以多執行緒之間，陣列會進行共享，當有一個執行緒修改了其值，會立即同步到主存中，當下一次再get的時候會發現和上一次get的值不同，因此讀操作會發生髒讀。

private E get(Object[] a, int index) { return (E) a[index]; } public E get(int index) { return get(getArray(), index); } 

我們再來看看它的迭代器

static final class COWIterator<E> implements ListIterator<E> { private final Object[] snapshot; private int cursor; private COWIterator(Object[] elements, int initialCursor) { cursor = initialCursor; snapshot = elements; } public boolean hasNext() { return cursor < snapshot.length; } public boolean hasPrevious() { return cursor > 0; } @SuppressWarnings("unchecked") public E next() { if (! hasNext()) throw new NoSuchElementException(); return (E) snapshot[cursor++]; } @SuppressWarnings("unchecked") 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(); } } 

我們知道ArrayList是非線性安全的集合，它使用迭代器時有可能會丟擲ConcurrentModificationException。而且併發的時候進行插入操作時，由於沒有進行同步操作，容易丟失資料。

可以看到，在COWIterator的迭代中，不能直接增刪改，避免了ConcurrentModificationException。

3、CopyOnWriteArraySet的實現原理

通過原始碼可以看到，CopyOnWriteArraySet內部維護著一個CopyOnWriteArrayList，所有的操作都是通過它去完成的。

private final CopyOnWriteArrayList<E> al; /** * Creates an empty set. */ public CopyOnWriteArraySet() { al = new CopyOnWriteArrayList<E>(); } 

我們主要看看add(E)方法的實現，它呼叫了CopyOnWriteArrayList的addIfAbsent方法

public boolean addIfAbsent(E e) { // 當前陣列的一個快照 Object[] snapshot = getArray(); // 如果傳入的元素存在，直接返回false，否則增加 return indexOf(e, snapshot, 0, snapshot.length) >= 0 ? false : addIfAbsent(e, snapshot); } private boolean addIfAbsent(E e, Object[] snapshot) { final ReentrantLock lock = this.lock; lock.lock(); try { Object[] current = getArray(); int len = current.length; // 傳入的陣列和當前陣列不一樣 if (snapshot != current) { // Optimize for lost race to another addXXX operation int common = Math.min(snapshot.length, len); for (int i = 0; i < common; i++) if (current[i] != snapshot[i] && eq(e, current[i])) return false; if (indexOf(e, current, common, len) >= 0) return false; } // 建立一個新陣列，長度為原陣列長度+1 Object[] newElements = Arrays.copyOf(current, len + 1); newElements[len] = e; setArray(newElements); return true; } finally { lock.unlock(); } } 

4、自己實現CopyOnWriteMap

JDK中並沒有提供CopyOnWriteMap，我們可以參考CopyOnWriteArrayList來實現一個，基本程式碼如下：

import java.util.Collection;
import java.util.Map; import java.util.Set; public class CopyOnWriteMap<K, V> implements Map<K, V>, Cloneable { private volatile Map<K, V> internalMap; public CopyOnWriteMap() { internalMap = new HashMap<K, V>(); } public V put(K key, V value) { synchronized (this) { Map<K, V> newMap = new HashMap<K, V>(internalMap); V val = newMap.put(key, value); internalMap = newMap; return val; } } public V get(Object key) { return internalMap.get(key); } public void putAll(Map<? extends K, ? extends V> newData) { synchronized (this) { Map<K, V> newMap = new HashMap<K, V>(internalMap); newMap.putAll(newData); internalMap = newMap; } } } 

實現很簡單，只要瞭解了CopyOnWrite機制，我們可以實現各種CopyOnWrite容器，並且在不同的應用場景中使用。

5、CopyOnWrite的應用場景

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

package com.github.book;

import java.util.Map; import com.github.book.forkjoin.CopyOnWriteMap; /** * 黑名單服務 */ public class BlackListServiceImpl { private static CopyOnWriteMap<String, Boolean> blackListMap = new CopyOnWriteMap<String, Boolean>(1000); public static boolean isBlackList(String id) { return blackListMap.get(id) == null ? false : true; } public static void addBlackList(String id) { blackListMap.put(id, Boolean.TRUE); } /** * 批量新增黑名單 * * @param ids */ public static void addBlackList(Map<String,Boolean> ids) { blackListMap.putAll(ids); } } 

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

1. 減少擴容開銷。根據實際需要，初始化CopyOnWriteMap的大小，避免寫時CopyOnWriteMap擴容的開銷。
2. 使用批量新增。因為每次新增，容器每次都會進行復制，所以減少新增次數，可以減少容器的複製次數。如使用上面程式碼裡的addBlackList方法。

6、CopyOnWrite的缺點

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

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

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

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

7、對比Collections.synchronizedList

CopyOnWriteArrayList和Collections.synchronizedList是實現執行緒安全的列表的兩種方式。兩種實現方式分別針對不同情況有不同的效能表現。

因為CopyOnWriteArrayList的寫操作不僅有lock鎖，還在內部進行了陣列的copy，所以效能比Collections.synchronizedList要低。

而讀操作CopyOnWriteArrayList直接取的陣列的值，Collections.synchronizedList卻有synchronized修飾，所以讀效能CopyOnWriteArrayList略勝一籌。

因此在不同的應用場景下，應該選擇不同的多執行緒安全實現類。

總結：CopyOnWriteArrayList，發生修改時候做copy，新老版本分離，保證讀的高效能，適用於以讀為主，讀操作遠遠大於寫操作的場景中使用，比如快取。而Collections.synchronizedList則可以用在CopyOnWriteArrayList不適用，但是有需要同步列表的地方，讀寫操作都比較均勻的地方。

參考：JAVA中的COPYONWRITE容器

from: http://benjaminwhx.com/2018/05/03/%E3%80%90%E7%BB%86%E8%B0%88Java%E5%B9%B6%E5%8F%91%E3%80%91%E8%B0%88%E8%B0%88Copy-On-Write%E5%AE%B9%E5%99%A8/