CopyOnWriteArrayList分析

1. 屬性開始

private static final long serialVersionUID = 8673264195747942595L;

    // 排他鎖
    final transient ReentrantLock lock = new ReentrantLock();

 // 數組的方法是通過getArray和setArray
    private transient volatile Object[] array;

2. 構造方法開始

無參構造

// 給array賦，賦一個Object[0]的數組，沒有啥子長度的數組
public CopyOnWriteArrayList() {
        setArray(new Object[0]);
  }

傳遞一個collection

傳遞進來c變為數組，通過
Arrays.copyOf 拷貝一個新的數組，指派給 elements ，關于Arrays.copyOf，這底層就是調用 System.arraycopy 方法。

public CopyOnWriteArrayList(Collection<? extends E> c) {
        Object[] elements;
        if (c.getClass() == CopyOnWriteArrayList.class)
            elements = ((CopyOnWriteArrayList<?>)c).getArray();
        else {
            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);
    }

剩下的api基本就是操作數組元素的了，在

ArrayList分析過

，這裡就在累贅的說了。下面主要分析一下add，set方法和get方法。

add 方法分析

這裡的邏輯也很簡單了，擷取鎖，每次都是利用拷貝數組，每次都先拷貝一個length + 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();
        }
    }

set(int index, E element) 分析

替換指定下标的元素。如果指定的位置沒有元素，就将數組重新設定回去。

如果指定的位置有值，注意，這裡比較采用的還是

引用比較

。不一樣的話，就會重新拷貝一份，然後指定位置下标，獲得新數組，然後重新設定值。

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;
               // 重新設定新數組，在volatile修飾的變量，能讓值強制重新整理會工作記憶體，并且會使别的線程擷取值的時候從工作記憶體中擷取值。包裝記憶體一緻性
                setArray(newElements);
            } else {
                // Not quite a no-op; ensures volatile write semantics
                setArray(elements);
            }
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

get方法分析

get方法很簡單，就是通過下标擷取數組中的對應的元素。着實很簡單。

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

remove(int index) 方法分析

這裡并沒有想ArrayList一樣，直接在原來的數組上面操作，而是重新new了一個數組，然後複制過去。

問題？

為什麼這麼做？

數組對象的配置設定是在堆裡面的，直接利用
System.arraycopy 操作原來的數組，不能保證記憶體的一直性，因為沒有指派（==）操作，是以，這裡要重新建立數組，之後調用setArray方法設定值。

public E remove(int index) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        // 或者index的元素
        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];
            System.arraycopy(elements, 0, newElements, 0, index);
            System.arraycopy(elements, index + 1, newElements, index,
                             numMoved);
            setArray(newElements);
        }
        return oldValue;
    } finally {
        lock.unlock();
    }
}

别的方法基本都是大同小異，先擷取鎖，在擷取數組，正常的操作array，隻要記住，隻要涉及到變更的操作，都要建立新數組，在新的數組上面操作，之後通過set方法将新的數組set進去。

問題？

每次擷取的時候 ReentrantLock 都有加鎖和解鎖的操作，為啥還要用 volatile
來修飾。

ReentrantLock是javaApi來實作的，主要還是通過Park和unPark來阻塞線程，隻能保證原子性。

在
CopyOnWriteArrayList 裡面用volatile修飾 array 能保證記憶體一緻性。

疊代器

CopyOnWriteArrayList 的疊代器和ArrayList大多數集合不一樣，這裡沒有快速失敗的機制。那就說明，在疊代器和CopyOnWriteArrayList 裡面沒有modCount操作。也沒有檢查的機制。

COWIterator的疊代器不支援remove,set,add操作，是以在ArrayList分析裡面列舉的例子在 CopyOnWriteArrayList 場景下面不會出錯。

public Spliterator<E> spliterator() {
        return Spliterators.spliterator
            (getArray(), Spliterator.IMMUTABLE | Spliterator.ORDERED);
    }

    static final class COWIterator<E> implements ListIterator<E> {
        /** Snapshot of the array */
        private final Object[] snapshot;
        /** Index of element to be returned by subsequent call to next.  */
        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();
        }

        /**
         * Not supported. Always throws UnsupportedOperationException.
         * @throws UnsupportedOperationException always; {@code set}
         *         is not supported by this iterator.
         */
        public void set(E e) {
            throw new UnsupportedOperationException();
        }

        /**
         * Not supported. Always throws UnsupportedOperationException.
         * @throws UnsupportedOperationException always; {@code add}
         *         is not supported by this iterator.
         */
        public void add(E e) {
            throw new UnsupportedOperationException();
        }

        @Override
        public void forEachRemaining(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            Object[] elements = snapshot;
            final int size = elements.length;
            for (int i = cursor; i < size; i++) {
                @SuppressWarnings("unchecked") E e = (E) elements[i];
                action.accept(e);
            }
            cursor = size;
        }
    }

總結

ArrayList 線程安全的代替類。多線程的情況下使用。
不支援通過疊代器來操作List。
沒有快速失敗機制
每次隻要涉及到更改，就會從拿到數組，複制新數組，用新數組指派。利用 volatile 來實作記憶體一緻性。
複制數組耗費記憶體空間，導緻記憶體空間的使用率低。是以，在讀多寫少的情況下，使用還是很不錯的。但是話說回來，在寫操作多的情況下，感覺也差不了多少。鎖隻有一把，肯定不會造成多個線程同時複制，無非也就是拷貝的操作在一個時間段之内多了點。
CopyOnWriteArraySet 是基于 CopyOnWriteArrayList 實作的，主要是利用 addIfAbsent 方法。先查找，如果沒有查找到就添加

CopyOnWriteArrayList分析CopyOnWriteArrayList分析

CopyOnWriteArrayList分析

1. 屬性開始

2. 構造方法開始

add 方法分析

set(int index, E element) 分析

get方法分析

remove(int index) 方法分析

疊代器

總結

繼續閱讀

關于Gradle配置的小結

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method