ArrayList和CopyOnWriteArrayList
原文地址
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支持讀多寫少的併發情況。
