文章目錄

前言

CopyOnWriteArrayList 是一種寫時複製的ArrayList，它將讀操作和寫操作的情形區分開來，並在寫操作時拷貝原數組成員。

核心成員

    /** 寫操作時用來加鎖 */
    final transient ReentrantLock lock = new ReentrantLock();

    /** 底層數組實現。注意volatile修飾在數組引用上 */
    private transient volatile Object[] array;

    /**
     * 得到數組引用
     */
    final Object[] getArray() {
        return array;
    }

    /**
     * 設置數組
     */
    final void setArray(Object[] a) {
        array = a;
    }

    /**
     * 默認構造器。生成大小爲0的數組
     */
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }

在寫操作時，ReentrantLock用來加鎖。
數組引用是volatile的，保證了可見性。get/set方法的具體操作是return和賦值，所以這兩個操作具有原子性。結合了可見性和原子性，所以get/set方法不需要CAS操作就可以保證在多線程環境下能正常工作。
最讓人疑惑的是，爲什麼默認構造器中生成的數組大小爲0。array成員也不是final的，看來使用過程中，會不停對array成員賦值了。

常用方法

現在我們從CopyOnWriteArrayList提供的public方法入手，看看它是怎麼做到Copy On Write的。

get

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

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

get操作自然是一個讀操作，所以全程都不用加鎖。

set

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

set操作自然是一個寫操作，所以需要加鎖。具體過程是，複製出一個一模一樣的新數組出來，然後將新數組對應索引設置爲新值，最後把新數組賦值給array成員。

需要注意到，get操作是無鎖的，set操作卻是加鎖的。也就是說，get操作可以在set操作過程中的任何時刻進行，具體的講：

在set操作的setArray(newElements)之前，執行了get操作的getArray()，那麼get操作的是舊數組。
在set操作的setArray(newElements)之後，執行了get操作的getArray()，那麼get操作的是新數組。

看到這裏，你已經發現了CopyOnWrite的祕密了，簡單的說：無論有多少個讀寫操作在進行中，這些讀寫操作持有的數組引用最多可能是兩個不同的數組，寫操作因爲加鎖操作而互斥，所以新數組在一個時刻只可能產生一個，再算上舊數組——所以最多可能是兩個不同的數組。

add

add也是寫操作，需要加鎖。

    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            //新數組大小比原數組大小 加1，但最後一個位置是空的
            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;
            //原本索引範圍0 - len-1,新的索引範圍應爲0 - len，所以下面這麼檢查
            if (index > len || index < 0)
                throw new IndexOutOfBoundsException("Index: "+index+
                                                    ", Size: "+len);
            Object[] newElements;
            int numMoved = len - index;
            if (numMoved == 0)//如果index剛好是len，說明一個元素都不用後移了
                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();
        }
    }

這個版本的add可以將新元素插入到指定的位置。

remove

remove也是寫操作，需要加鎖。

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);//需要返回舊值
            //刪除前索引範圍是0 - len-1,所以下面其實是len-1 - index
            int numMoved = len - index - 1;
            if (numMoved == 0)//如果index剛好是len-1，說明一個元素都不用前移了
                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();
        }
    }

這個版本用來刪除指定索引上的元素。

remove(Object o)

    public boolean remove(Object o) {
        Object[] snapshot = getArray();
        int index = indexOf(o, snapshot, 0, snapshot.length);//如果元素存在，則返回一個有效索引
        //如果索引無效，直接返回false
        return (index < 0) ? false : remove(o, snapshot, index);
    }

    private boolean remove(Object o, Object[] snapshot, int index) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] current = getArray();
            int len = current.length;
            //如果數組成員已經改變，需要重新考察index的有效性，因爲之後會根據這個index操作
            if (snapshot != current) findIndex: {
            	//得到遍歷範圍最小值，這個範圍不一定能找到元素，當元素被後移時
            	//注意index是索引，len是數組大小。
                int prefix = Math.min(index, len);
                for (int i = 0; i < prefix; i++) {
                	//嚴格的判斷。只有當兩個數組相同索引位置的元素不是同一個元素；
                	//且current索引元素和參數o 是equal的
                    if (current[i] != snapshot[i] && eq(o, current[i])) {
                        index = i;
                        break findIndex;//一旦判定成功，退出if分支
                    }
                }
                //如果index >= len，那麼說明循環遍歷了current每個元素都沒有退出if分支
                if (index >= len)
                    return false;
                //接下來檢查[index, len)範圍內的元素
                if (current[index] == o)
                    break findIndex;
                index = indexOf(o, current, index, len);
                if (index < 0)
                    return false;
            }
            Object[] newElements = new Object[len - 1];
            System.arraycopy(current, 0, newElements, 0, index);
            System.arraycopy(current, index + 1,
                             newElements, index,
                             len - index - 1);
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

這個版本用來刪除指定對象。但由於調用私有方法後纔開始加鎖，所以可能私有方法時，數組成員已經改變。

注意java冒號的這種用法，用來退出代碼塊。

分析的重點在於if (snapshot != current) 內的內容。
可以分爲兩種情況：

index >= len
index < len

注意index是從snapshot裏找來的索引，len則是current的大小。

index >= len

當index >= len時，for循環一定能遍歷完所有的節點，如果遍歷結束後都沒有退出if分支，那麼之後if (index >= len) return false;就一定會退出if分支。

圖例說明，D爲indexOf找到的那個的元素。

上圖例舉了index = len的情況，可見這種情況可以確定current相比snapshot，元素減少了。如果index > len，那更是如此。也就是說int prefix = Math.min(index, len)肯定取到的是len，循環一定能夠遍歷到current的每個元素。但問題在於爲什麼要用if (current[i] != snapshot[i] && eq(o, current[i]))這麼嚴格的判斷，只使用這個判斷的後者不行嗎？

之所以這樣，是因爲最開始是通過indexOf(o, snapshot, 0, snapshot.length)算出來的index，這個indexOf的內部邏輯是通過equals判斷的，現在indexOf得到的索引是3，那麼說明前面的ABC既不是o本身，也不能通過o.equals判斷相等。

現在既然已知了o不可能和snapshot前面的元素是同一個元素（==判斷），所以if (current[i] != snapshot[i] && eq(o, current[i]))使用這麼嚴格的判斷也是合理的，顯得更加嚴謹。

index < len

當index < len時，for循環不能遍歷完所有的節點。現在prefix肯定是index了，至少for循環已經檢查了[0,index)範圍內的元素，但都還沒有找到o。

所以接下來需要檢查[index,len)範圍內的元素（indexOf(o, current, index, len)），前面的if (current[index] == o) break findIndex;只是一種快速嘗試，運氣好的話，index索引剛好是o本身。

現在兩種情況都分析完了，如果最後了發現index < 0，說明current裏面沒有o本身或能通過o.equals()判斷的元素。

findIndex代碼塊之後

現在index已經被找到，執行相應操作

clear

clear也是寫操作，需要加鎖。

    public void clear() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            setArray(new Object[0]);//賦值爲大小爲0的元素
        } finally {
            lock.unlock();
        }
    }

toArray

誰也不知道你執行toArray後，會不會拿去寫操作，所以這裏還是得返回一個副本。

    public <T> T[] toArray(T a[]) {
        Object[] elements = getArray();
        int len = elements.length;
        if (a.length < len)
            return (T[]) Arrays.copyOf(elements, len, a.getClass());
        else {
            System.arraycopy(elements, 0, a, 0, len);
            if (a.length > len)
                a[len] = null;
            return a;
        }
    }

迭代器

    public Iterator<E> iterator() {
        return new COWIterator<E>(getArray(), 0);
    }

可以發現迭代器接受的是getArray()，即直接使用的CopyOnWriteArrayList的數組成員引用，看來這個迭代器想必是不支持寫操作的了，只支持讀操作了。因爲讀操作纔是這樣，不加鎖，直接獲取數組成員。

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

        @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;
        }
    }

總結

volatile + return操作/賦值操作，保證了數組成員的可見性和原子性。
讀操作不用加鎖，直接獲取數組成員。
寫操作需要加鎖，並拷貝原數組成員。

優點：

保留了讀操作的高性能。
避免了併發修改拋出的ConcurrentModificationException異常。

缺點：

寫操作太多時，將產生高內存消耗。因爲需要拷貝出新數組。
讀操作不能保證看到最新的數據，即使寫操作已經開始執行了。因爲直到寫操作執行setArray之前，讀操作都無法看到最新數據。

場景：

讀操作多，寫操作少的場景。
讀操作允許看到非最新數據的場景。

JUC集合類 CopyOnWriteArrayList源碼解析 JDK8

文章目錄

前言

核心成員

常用方法

get

set

add

remove

remove(int index)

remove(Object o)

index >= len

index < len

findIndex代碼塊之後

clear

toArray

迭代器

總結

HTML頁面關於高分屏的設置

北歐瑞典挪威芬蘭瑞士TikTok海外網紅與YouTube博主的合作模式

歐洲英國德國法國TikTok與YouTube海外網紅達人的完美合作策略

druid數據源 xml配置

JUC集合類 CopyOnWriteArrayList源碼解析 JDK8

JUC集合類 CopyOnWriteArraySet源碼解析 JDK8

ReentrantReadWriteLock的readerShouldBlock與apparentlyFirstQueuedIsExclusive 深入理解讀鎖的非公平實現

SocketChannel 使用open或connect/finishConnect

Java反射獲得Class對象的五種方法

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結