ArrayList 和 CopyOnWriteArrayList

這篇文章的目的以下：

• 瞭解一下ArrayList和CopyOnWriteArrayList的增刪改查實現原理
• 看看爲何說ArrayList查詢快而增刪慢？
• CopyOnWriteArrayList爲何併發安全且性能比Vector好

1. List接口

首先咱們來看看List接口，由於ArrayList和CopyOnWriteArrayList都是實現了List接口，咱們今天主要是研究增刪改查原理，因此只看相應的方法便可。

public interface List<E> extends Collection<E> {
 
    int size();
    boolean isEmpty();
    boolean contains(Object o);
    Iterator<E> iterator();
    Object[] toArray();
    <T> T[] toArray(T[] a);
    boolean add(E e);
    boolean remove(Object o);
    boolean containsAll(Collection<?> c);
    boolean addAll(Collection<? extends E> c);
    boolean addAll(int index, Collection<? extends E> c);
    boolean removeAll(Collection<?> c);
    boolean retainAll(Collection<?> c);
    void clear();
    boolean equals(Object o);
    int hashCode();

    E get(int index);
    E set(int index, E element);
    void add(int index, E element);
    E remove(int index);
    int indexOf(Object o);
    int lastIndexOf(Object o);
    ListIterator<E> listIterator();
    ListIterator<E> listIterator(int index);
    List<E> subList(int fromIndex, int toIndex);
}

2 ArrayList

2.1 幾個重點

• 底層是數組，初始大小爲10
• 插入時會判斷數組容量是否足夠，不夠的話會進行擴容
• 所謂擴容就是新建一個新的數組，而後將老的數據裏面的元素複製到新的數組裏面
• 移除元素的時候也涉及到數組中元素的移動，刪除指定index位置的元素，而後將index+1至數組最後一個元素往前移動一個格

2.2 增刪改查

1）增

public boolean add(E e) {
    //進行數組容量判斷，不夠就擴容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
 }

 
public void add(int index, E element) {
    //檢查是否會越界
    rangeCheckForAdd(index);
    //進行數組容量判斷，不夠就擴容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //將index至數據最後一個元素總體日後移動一格，而後插入新的元素
    System.arraycopy(elementData, index, elementData, index + 1,
                    size - index);
    elementData[index] = element;
    size++;
}

2）刪

public E remove(int index) {
    //判斷是否越界
    rangeCheck(index);

    modCount++;
    E oldValue = elementData(index);

    int numMoved = size - index - 1;
    //若該元素不是最後一個元素的話，將index+1至數組最後一個元素總體向前移動一格
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
    }

3）改

public E set(int index, E element) {
    rangeCheck(index);

    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

邏輯很簡單，將數組對應index的元素進行替換

4）查

public E get(int index) {
    rangeCheck(index);

    return elementData(index);
}

E elementData(int index) {return (E) elementData[index]; }

邏輯很簡單，進行數組越界判斷，獲取數組對應index的元素

2.3 總結

以上部分就是ArrayList的增刪改查原理，以此也能夠解答咱們第二個問題了，ArrayList的底層是數組，因此查詢的時候直接根據索引能夠很快找到對應的元素，改也是如此，找到index對應元素進行替換。而增長和刪除就涉及到數組元素的移動，因此會比較慢。

3 CopyOnWriteArrayList

3.1 幾個要點

• 實現了List接口
• 內部持有一個ReentrantLock lock = new ReentrantLock();
• 底層是用volatile transient聲明的數組 array
• 讀寫分離，寫時複製出一個新的數組，完成插入、修改或者移除操做後將新數組賦值給array

3.2 增刪改查

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

3.3 總結

從以上的增刪改查中咱們能夠發現，增刪改都須要得到鎖，而且鎖只有一把，而讀操做不須要得到鎖，支持併發。爲何增刪改中都須要建立一個新的數組，操做完成以後再賦給原來的引用？這是爲了保證get的時候都能獲取到元素，若是在增刪改過程直接修改原來的數組，可能會形成執行讀操做獲取不到數據。

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

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