併發容器CopyOnWriteArrayList

時間  2019-11-15
標籤 併發 容器 copyonwritearraylist 欄目 Java 简体版
原文   原文鏈接

Copy-On-Write簡稱COW，是一種用於程序設計中的優化策略。其基本思路是，從一開始你們都在共享同一個內容，當某我的想要修改這個內容的時候，纔會真正把內容Copy出去造成一個新的內容而後再改，這是一種延時懶惰策略。從JDK1.5開始Java併發包裏提供了兩個使用CopyOnWrite機制實現的併發容器,它們是CopyOnWriteArrayList和CopyOnWriteArraySet。CopyOnWrite容器很是有用，能夠在很是多的併發場景中使用到。java

CopyOnWrite容器即寫時複製的容器。通俗的理解是當咱們往一個容器添加元素的時候，不直接往當前容器添加，而是先將當前容器進行Copy，複製出一個新的容器，而後新的容器裏添加元素，添加完元素以後，再將原容器的引用指向新的容器。這樣作的好處是咱們能夠對CopyOnWrite容器進行併發的讀，而不須要加鎖，由於當前容器不會添加任何元素。因此CopyOnWrite容器也是一種讀寫分離的思想，讀和寫不一樣的容器。數組

CopyOnWriteArrayList至關於線程安全的ArrayList，經過增長寫時複製語義來實現線程安全性。底層也是經過一個可變數組來實現的。可是和ArrayList不一樣的時，它具備如下特性：安全

  1.  它最適合於具備如下特徵的應用程序：List 大小一般保持很小，只讀操做遠多於可變操做，須要在遍歷期間防止線程間的衝突
  2.  支持高效率併發且是線程安全的
  3.  由於一般須要複製整個基礎數組，因此可變操做（add()、set() 和 remove() 等等）的開銷很大
  4.  迭代器支持hasNext(), next()等不可變操做，但不支持可變 remove()等操做
  5.  使用迭代器進行遍歷的速度很快，而且不會與其餘線程發生衝突。在構造迭代器時，迭代器依賴於不變的數組快照

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

array: 保存了列表中的數據多線程

lock: 修改時加鎖，用於保證線程安全併發

底層數據結構依然是數組，相比較於ArrayList而言，少了一個表示數組長度的size變量，獲取列表長度是經過下面的方法函數

首先來看一下構造函數，以下所示：性能

    private volatile transient Object[] array;優化

    final Object[] getArray() {
        return array;
    }
    final void setArray(Object[] a) {
        array = a;
    }
    // -----開始構造函數----------------------------
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }
    public CopyOnWriteArrayList(Collection<? extends E> c) {
        Object[] elements = c.toArray();
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elements.getClass() != Object[].class)
            elements = Arrays.copyOf(elements, elements.length, Object[].class);
        setArray(elements);
    }
    // Creates a list holding a copy of the given array.
    public CopyOnWriteArrayList(E[] toCopyIn) {
        setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
    }網站

使用一個指向volatile類型的Object數組來保存容器元素。構造函數中都會根據參數值從新生成一個新的數組。

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

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

ArrayList新增元素時，可能致使數組擴容；CopyOnWriteArrayList在列表的修改時，採用數組拷貝，在新的數組上進行操做，從這點出發，應該不存在擴容的問題，由於每次修改都會致使數組的從新拷貝

有兩點必須清楚：

 第一，在」添加操做「開始前，獲取獨佔鎖(lock)，若此時有須要線程要獲取鎖，則必須等待；在操做完畢後，釋放獨佔鎖(lock)，此時其它線程才能獲取鎖。經過獨佔鎖，來防止多線程同時修改數據！

 第二，操做完畢時，會經過setArray()來更新volatile數組。對一個volatile變量的讀，老是能看到（任意線程）對這個volatile變量最後的寫入；這樣，每次添加元素以後，其它線程都能看到新添加的元素。

2.獲取元素：

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

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

將底層volatile數組指定索引處的元素返回便可。

3.刪除元素：

以remove(int index)爲例，來對「CopyOnWriteArrayList的刪除操做」進行說明。下面是remove(int index)的代碼：

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); // 獲取volatile數組中指定索引處的元素值
        int numMoved = len - index - 1;
        if (numMoved == 0) // 若是被刪除的是最後一個元素，則直接經過Arrays.copyOf()進行處理，而不須要新建數組
            setArray(Arrays.copyOf(elements, len - 1));
        else {
            Object[] newElements = new Object[len - 1];
            System.arraycopy(elements, 0, newElements, 0, index);    // 拷貝刪除元素前半部分數據到新數組中
            System.arraycopy(elements, index + 1, newElements, index, numMoved);// 拷貝刪除元素後半部分數據到新數組中
            setArray(newElements); // 更新volatile數組
        }
        return oldValue;
    } finally {
        lock.unlock();
    }
}

從刪除的實現，可肯定如下幾點：

  • 修改加鎖，確保同一時刻只有一個線程對數組進行修改

  • 修改並非在原數組上進行的，而是建立一個新的數組，在新的數組上進行操做操做，而後將tables引用指向新的數組

  • 修改必然會涉及到數組內容的拷貝

4.遍歷元素：

public Iterator<E> iterator() {
        return new COWIterator<E>(getArray(), 0);
    }
    public ListIterator<E> listIterator() {
        return new COWIterator<E>(getArray(), 0);
    }
    public ListIterator<E> listIterator(final int index) {
        Object[] elements = getArray();
        int len = elements.length;
        if (index<0 || index>len)
            throw new IndexOutOfBoundsException("Index: "+index);

        return new COWIterator<E>(elements, index);
    }

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

如上容器的迭代器中會保存一個不可變的Object數組對象，那麼在進行遍歷這個對象時就不須要再進一步的同步。在每次修改時，都會建立並從新發佈一個新的窗口副本，從而實現了可變性。如上迭代器代碼中保留了一個指向volatile數組的引用，因爲不會被修改，所以多個線程能夠同時對它進行迭代，而不會彼此干擾或與修改容器的線程相互干擾。

與以前的ArrayList實現相比，CopyOnWriteArrayList返回迭代器不會拋出ConcurrentModificationException異常，即它不是fail-fast機制的！

 

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

package com.ifeve.book;

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

    }

}

實現很簡單，只要瞭解了CopyOnWrite機制，咱們能夠實現各類CopyOnWrite容器，而且在不一樣的應用場景中使用。

　代碼很簡單，可是使用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容器。

多記錄一句：

Collections.synchronizedList & CopyOnWriteArrayList

       CopyOnWriteArrayList和Collections.synchronizedList是實現線程安全的列表的兩種方式。兩種實現方式分別針對不一樣狀況有不一樣的性能表現，其中CopyOnWriteArrayList的寫操做性能較差，而多線程的讀操做性能較好。而Collections.synchronizedList的寫操做性能比CopyOnWriteArrayList在多線程操做的狀況下要好不少，而讀操做由於是採用了synchronized關鍵字的方式，其讀操做性能並不如CopyOnWriteArrayList。所以在不一樣的應用場景下，應該選擇不一樣的多線程安全實現類。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程