快捷導(dǎo)航

Java中的CopyOnWriteArrayList原理詳解

更新時(shí)間：2023年12月27日 10:58:10 作者：笑我歸無處

這篇文章主要介紹了Java中的CopyOnWriteArrayList原理詳解,如源碼所示,CopyOnWriteArrayList和ArrayList一樣,都在內(nèi)部維護(hù)了一個(gè)數(shù)組,操作CopyOnWriteArrayList其實(shí)就是在操作內(nèi)部的數(shù)組,需要的朋友可以參考下

CopyOnWriteArrayList的原理是什么

CopyOnWriteArrayList是線程安全版本的ArrayList。

這里先上一小段源碼

final transient ReentrantLock lock = new ReentrantLock();
/** The array, accessed only via getArray/setArray. */
private transient volatile Object[] array;
/**
 * Gets the array.  Non-private so as to also be accessible
 * from CopyOnWriteArraySet class.
 */
final Object[] getArray() {
    return array;
}
/**
 * Sets the array.
 */
final void setArray(Object[] a) {
    array = a;
}
/**
 * Creates an empty list.
 */
public CopyOnWriteArrayList() {
    setArray(new Object[0]);
}

如源碼所示，CopyOnWriteArrayList和ArrayList一樣，都在內(nèi)部維護(hù)了一個(gè)數(shù)組。操作CopyOnWriteArrayList其實(shí)就是在操作內(nèi)部的數(shù)組。

但關(guān)鍵是和ArrayList的不同之處

1) 使用volatile修飾內(nèi)部數(shù)組

private transient volatile Object[] array;

看這行代碼，使用volatile修飾了內(nèi)部數(shù)組 volatile關(guān)鍵字保證了每次拿到的內(nèi)部數(shù)組都是最新值。因?yàn)関olatile關(guān)鍵字表示直接去主存中獲取值，因此哪怕別的線程剛修改完內(nèi)部數(shù)組，也能保證獲取內(nèi)部數(shù)組時(shí)是最新的。

2) 加鎖

提到并發(fā)編程，當(dāng)然少不了加鎖。

final transient ReentrantLock lock = new ReentrantLock();

CopyOnWriteArrayList每創(chuàng)建一個(gè)實(shí)例，都會(huì)同時(shí)創(chuàng)建一個(gè)ReentrantLock鎖。 CopyOnWriteArrayList會(huì)在增，刪，改操作時(shí)添加鎖，而不會(huì)在讀操作時(shí)加鎖。

3) 使用COW思想操作數(shù)組。

COW即是CopyOnWrite的縮寫。即每次在寫入之前，先獲取源數(shù)據(jù)的拷貝，修改完拷貝后，再保存到源數(shù)據(jù)中。

get操作

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

如源碼所示，get操作沒有加鎖，直接返回?cái)?shù)組中的對(duì)象。

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

大致流程：

加鎖
獲取源數(shù)組
判斷新值和舊值是否相同
不同的話拷貝源數(shù)組，更新值，然后更新源數(shù)組
相同的話，不更新值，然后更新源數(shù)組(數(shù)組內(nèi)容沒變)
釋放鎖

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

大致流程：

加鎖
獲取源數(shù)組
復(fù)制一個(gè)源數(shù)組長度+1的新數(shù)組
在數(shù)組末尾賦值，然后更新源數(shù)組
釋放鎖

remove操作

public E remove(int index) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        E oldValue = get(elemnts, 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();
    }
}

大致流程：