面試官：連CopyOnWriteArrayList都沒聽過

寫入時複製（CopyOnWrite）思想

寫入時複製（CopyOnWrite，簡稱COW）思想是計算機程序設計領域中的一種優化策略。其核心思想是，若是有多個調用者（Callers）同時要求相同的資源（如內存或者是磁盤上的數據存儲），他們會共同獲取相同的指針指向相同的資源，直到某個調用者視圖修改資源內容時，系統纔會真正複製一份專用副本（private copy）給該調用者，而其餘調用者所見到的最初的資源仍然保持不變。這過程對其餘的調用者都是透明的（transparently）。此作法主要的優勢是若是調用者沒有修改資源，就不會有副本（private copy）被建立，所以多個調用者只是讀取操做時能夠共享同一份資源。

CopyOnWriteArrayList的實現原理

在使用CopyOnWriteArrayList以前，咱們先閱讀其源碼瞭解下它是如何實現的。如下代碼是向CopyOnWriteArrayList中add方法的實現（向CopyOnWriteArrayList裏添加元素），能夠發如今添加的時候是須要加鎖的，不然多線程寫的時候會Copy出N個副本出來。

/**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return <tt>true</tt> (as specified by {@link Collection#add})
     */
    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();
    }
    }

讀的時候不須要加鎖，若是讀的時候有多個線程正在向CopyOnWriteArrayList添加數據，讀仍是會讀到舊的數據，由於寫的時候不會鎖住舊的CopyOnWriteArrayList。

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

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容器，而且在不一樣的應用場景中使用。

幾個要點

• 實現了List接口

• 內部持有一個ReentrantLock lock = new ReentrantLock();

• 底層是用volatile transient聲明的數組 array

• 讀寫分離，寫時複製出一個新的數組，完成插入、修改或者移除操做後將新數組賦值給array

「注：」

volatile （揮發物、易變的）：變量修飾符，只能用來修飾變量。volatile修飾的成員變量在每次被線程訪問時，都強迫從共享內存中重讀該成員變量的值。並且，當成員變量發生變 化時，強迫線程將變化值回寫到共享內存。這樣在任什麼時候刻，兩個不一樣的線程老是看到某個成員變量的同一個值。

增刪改查

1）增

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

   
public void add(int index, E element) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        if (index > len || index < 0)
            throw new IndexOutOfBoundsException("Index: "+index+
                                                ", Size: "+len);
        Object[] newElements;
        int numMoved = len - index;
        if (numMoved == 0)
            newElements = Arrays.copyOf(elements, len + 1);
        else {
            newElements = new Object[len + 1];
            System.arraycopy(elements, 0, newElements, 0, index);
            System.arraycopy(elements, index, newElements, index + 1,
                             numMoved);
        }
        newElements[index] = element;
        setArray(newElements);
    } finally {
        lock.unlock();
    }
}

2）刪

public E remove(int index) {
    final ReentrantLock lock = this.lock;
    //得到鎖
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        E oldValue = get(elements, index);
        int numMoved = len - index - 1;
        if (numMoved == 0)
            //若是刪除的元素是最後一個，直接複製該元素前的全部元素到新的數組
            setArray(Arrays.copyOf(elements, len - 1));
        else {
            //建立新的數組
            Object[] newElements = new Object[len - 1];
            //將index+1至最後一個元素向前移動一格
            System.arraycopy(elements, 0, newElements, 0, index);
            System.arraycopy(elements, index + 1, newElements, index,
                             numMoved);
            setArray(newElements);
        }
        return oldValue;
    } finally {
        lock.unlock();
    }
}

3）改

public E set(int index, E element) {
    final ReentrantLock lock = this.lock;
    //得到鎖
    lock.lock();
    try {
        Object[] elements = getArray();
        E oldValue = get(elements, index);

        if (oldValue != element) {
            int len = elements.length;
            //建立新數組
            Object[] newElements = Arrays.copyOf(elements, len);
            //替換元素
            newElements[index] = element;
            //將新數組指向原來的引用
            setArray(newElements);
        } else {
            // Not quite a no-op; ensures volatile write semantics
            setArray(elements);
        }
        return oldValue;
    } finally {
        //釋放鎖
        lock.unlock();
    }
}

4）查

//直接獲取index對應的元素
public E get(int index) {return get(getArray(), index);}
private E get(Object[] a, int index) {return (E) a[index];}

CopyOnWrite的應用場景

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

import java.util.Map;

import com.ifeve.book.forkjoin.CopyOnWriteMap;

/**
 * 黑名單服務
 *
 * @author fangtengfei
 *
 */
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方法。

CopyOnWrite的缺點

CopyOnWrite容器有不少優勢，可是同時也存在兩個問題，即內存佔用問題和數據一致性問題。因此在開發的時候須要注意一下。

「內存佔用問題」，由於CopyOnWrite的寫時複製機制，因此在進行寫操做的時候，內存裏會同時駐紮兩個對象的內存，舊的對象和新寫入的對象（注意:在複製的時候只是複製容器裏的引用，只是在寫的時候會建立新對象添加到新容器裏，而舊容器的對象還在使用，因此有兩份對象內存）。若是這些對象佔用的內存比較大，好比說200M左右，那麼再寫入100M數據進去，內存就會佔用300M，那麼這個時候頗有可能形成頻繁的Yong GC和Full GC。以前咱們系統中使用了一個服務因爲每晚使用CopyOnWrite機制更新大對象，形成了每晚15秒的Full GC，應用響應時間也隨之變長。

「針對內存佔用問題」，能夠經過壓縮容器中的元素的方法來減小大對象的內存消耗，好比，若是元素全是10進制的數字，能夠考慮把它壓縮成36進制或64進制。或者不使用CopyOnWrite容器，而使用其餘的併發容器，如ConcurrentHashMap。

「數據一致性問題」，CopyOnWrite容器只能保證數據的最終一致性，不能保證數據的實時一致性。因此若是你但願寫入的的數據，立刻能讀到，請不要使用CopyOnWrite容器。

CopyOnWriteArrayList爲何併發安全且性能比Vector好

我知道Vector是增刪改查方法都加了synchronized，保證同步，可是每一個方法執行的時候都要去得到鎖，性能就會大大降低，而CopyOnWriteArrayList 只是在增刪改上加鎖，可是讀不加鎖，在讀方面的性能就好於Vector，CopyOnWriteArrayList支持讀多寫少的併發狀況。

最後

感謝你們看到這裏，文章有不足，歡迎你們指出；若是你以爲寫得不錯，那就給我一個贊吧。

也歡迎你們關注個人公衆號：程序員麥冬，麥冬天天都會分享java相關技術文章或行業資訊，歡迎你們關注和轉發文章！