併發中的List集合
本文作者：王一飛，叩丁狼高階講師。原創文章，轉載請註明出處。
實際開發中, 我們使用頻率最高的容器估計是list集合,那肯定會遇併發操作.那該如何保證在多執行緒併發的環境下安全,高效的使用list集合呢?好,這就是今天我們聊話題:併發中的List集合.
List: 有序集合（也稱為序列 ）。使用者可以精確控制列表中每個元素的插入位置。 也可以通過整數索引（列表中的位置）訪問元素，並搜尋列表中的元素。 常用方法有:
新增: boolean add(E e);
刪除: boolean remove(Object o);
修改: E set(int index, E element);
查詢: E get(int index);
下面是List介面的實現體系:
常見的實現類:
ArrayList : 可調整大小的陣列的實現List介面
LinkedList :實現List和Deque介面的雙鏈表
Vector: 實現了可擴充套件的物件陣列,是同步的ArrayList
CopyOnWriteArrayList:帶有快照功能的讀寫安全併發容器類
Stack:最先進先出（LIFO）堆疊的物件
List集合實現類眾多,本篇挑出具有代表選3個實現類來逐一分析, 在併發環境下,它們的使用注意.
ArrayList 類其下所有操作方法都沒有使用任何加鎖痕跡,這表明該類是一個執行緒不安全類.比如下面新增的方法:
public boolean add(E e) { ensureCapacityInternal(size + 1); elementData[size++] = e; return true; }
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
在多執行緒環境下, 如果使用ArrayList進行操作時,可能存線上程不安全的隱患, 比如下面的例子:
需求:事先準備好一個集合list, 一個執行緒刪除最後一個元素, 一個執行緒清空list集合
public class App {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("1");
list.add("2");
new Thread(new Runnable() {
public void run() {
//集合大小
int len = list.size();
try {
//睡5s
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//刪除最後一個
list.remove(len-1);
}
}, "t1").start();
new Thread(new Runnable() {
public void run() {
//清空集合
list.clear();
}
}, "t2").start();
}
}
不出意外,執行緒t1,在執行list.remove操作時報錯了
Exception in thread "t1" java.lang.IndexOutOfBoundsException: Index: 1, Size: 0
at java.util.ArrayList.rangeCheck(ArrayList.java:653)
at java.util.ArrayList.remove(ArrayList.java:492)
at cn.wolfcode.ch13.App$1.run(App.java:20)
at java.lang.Thread.run(Thread.java:745)
分析:執行緒t1先執行,獲取到的list的size為2, 暫停5s, 執行緒t2開始執行, 清空list集合, 執行緒t1休眠時間結束,此時再刪除就出現陣列越界.因為資料已清空.
問: 怎麼解決這個問題, 可能有朋友提出使用Vector, 它是執行緒安全的, 確定麼?
Vector類出現時間比Arraylist早, 在JDK1.0 版本時候就出來了, JDK1.2版本之後納入的list集合體系.Vector 對外暴露的方法都是以synchronized修飾的, 也表示其自帶執行緒同步基因.天生是執行緒安全的.如下:
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
瞭解Vector類之後我們回到剛剛的問題, 將ArrayList改為Vector再看
public class App {
public static void main(String[] args) {
// ArrayList<String> list = new ArrayList<>();
Vector<String> list = new Vector<>();
list.add("1");
list.add("2");
new Thread(new Runnable() {
public void run() {
//集合大小
int len = list.size();
try {
//睡5s
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//刪除最後一個
list.remove(len-1);
}
}, "t1").start();
new Thread(new Runnable() {
public void run() {
//清空集合
list.clear();
}
}, "t2").start();
}
}
切換成Vector之後, 大家會發現,錯誤依舊, 什麼原因? 原因非常簡單, 是大家對Vector執行緒安全的誤解:
Vector確實是執行緒安全的, 但是它的安全是有前提的.併發環境下, vector只能保證同一時刻,唯一一個執行緒同步操作vector, 因為vector方法執行必須先得持有vector物件鎖.
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
在這前提下, 如果我們對Vector方法進行復合操作, Vector的同步也就是一個擺設. 比如上述例子中執行緒t1執行list.size()方法,此時執行緒t1持有list物件鎖.其他執行緒等待. 執行緒t1執行完list.size方法之後會釋放list物件鎖. 之後進入休眠. 執行緒t2獲取list物件鎖後, 遍可以操作list, 而一旦執行緒t2操作了list物件, 那陣列越界問題就出現了. 所以說, list.size 跟 list.remove 這2個方法 單獨操作時,是執行緒安全的, 一定分開操作,那vector就不是大家所認為的執行緒安全操作了.
至於上述問題怎麼解決, 只需要加額外的鎖, 保證list操作是同步即可
ArrayList
public class App {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("1");
list.add("2");
new Thread(new Runnable() {
public void run() {
synchronized (list){
//集合大小
int len = list.size();
try {
//睡5s
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//刪除最後一個
list.remove(len-1);
}
}
}, "t1").start();
new Thread(new Runnable() {
public void run() {
synchronized (list){
//清空集合
list.clear();
}
}
}, "t2").start();
}
}
Vector : 跟Arraylist區別是執行緒t2不需要給list加鎖, 預設已經加上了.
public class App {
public static void main(String[] args) {
Vector<String> list = new Vector<>();
list.add("1");
list.add("2");
new Thread(new Runnable() {
public void run() {
synchronized (list){
//集合大小
int len = list.size();
try {
//睡5s
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//刪除最後一個
list.remove(len-1);
}
}
}, "t1").start();
new Thread(new Runnable() {
public void run() {
//清空集合
list.clear();
}
}, "t2").start();
}
}
結論: Vector 在複合操作無法保證執行緒安全, 需要額外加鎖以保證執行緒安全.
JDK1.2之後提供一個工具類Collections用於對集合進行功能增強, 裡面有synchronizedList方法可以將普通的Arraylist轉換成執行緒安全的list, 具體操作:
ArrayList<String> list1 = new ArrayList<>();
List<String> list = Collections.synchronizedList(list1);
上面程式碼可以看到,普通的Arraylist作為引數,在執行完Collections.synchronizedList方法後可以得到執行緒安全的list集合.具體怎麼做到的呢?
一起看下原始碼
Collections:
public static <T> List<T> synchronizedList(List<T> list) {
return (list instanceof RandomAccess ?
new SynchronizedRandomAccessList<>(list) :
new SynchronizedList<>(list));
}
呼叫synchronizedList,它底層有個三元判斷表示式, 這裡姑且不理會判斷邏輯, 繼續點入SynchronizedRandomAccessList 會發現它其實是SynchronizedList一個子類, 所以我們只需要跟蹤SynchronizedList類即可.再深入.
Collections$SynchronizedList: Collections靜態內部類:
static class SynchronizedList<E>
extends SynchronizedCollection<E>
implements List<E> {
final List<E> list;
SynchronizedList(List<E> list) {
super(list);
this.list = list;
}
public E get(int index) {
synchronized (mutex) {return list.get(index);}
}
public E set(int index, E element) {
synchronized (mutex) {return list.set(index, element);}
}
public void add(int index, E element) {
synchronized (mutex) {list.add(index, element);}
}
public E remove(int index) {
synchronized (mutex) {return list.remove(index);}
}
//省略一堆方法
}
看方法,大家就可以發現,SynchronizedList會對傳入的ArrayList類進行功能增強, list中的crud方法都都進行加鎖處理.而鎖物件叫mutex.而這個mutex是啥, 我們繼續跟蹤, 點選SynchronizedList類繼承父類SynchronizedCollection,會發現, SynchronizedCollection還是Collections的靜態內部類
Collections$SynchronizedCollection
static class SynchronizedCollection<E> implements Collection<E>, Serializable {
private static final long serialVersionUID = 3053995032091335093L;
final Collection<E> c; // Backing Collection
final Object mutex; // Object on which to synchronize
SynchronizedCollection(Collection<E> c) {
this.c = Objects.requireNonNull(c);
mutex = this;
}
//再省略一堆方法
}
此時你會看到SynchronizedCollection持有一個final修飾的mutex屬性, 其構造器中的給mutex屬性賦值,而值恰恰是它自己.折騰來折騰去,大家會發現 Collections.synchronizedList(list1); 轉換的結果與Vector操作實現類似.換一句話說,在複合操作時Collections.synchronizedList(list1)也一樣需要額外加鎖控制保證執行緒安全.
前面Arraylist Vector synchronizedList 方法都無法優雅解決list的複合操作, 那這個
CopyOnWriteArrayList 應該可以解決了吧? 呵呵, 你想多了.CopyOnWriteArrayList設計確實是為了解決list複合操作執行緒安全問題.但是它針對僅僅是併發環境下讀與寫執行緒安全.簡單的講, 它只能保證, 一邊執行緒主讀(遍歷/獲取), 一邊執行緒主寫(新增/刪除/修改)操作上的安全. 而前面提到的例子,一邊執行緒讀寫, 一邊執行緒讀,這情景 已經不適用CopyOnWriteArrayList操作範疇了.
這時可能會朋友發問:CopyOnWriteArrayList能解決什麼問題? 敬請期待下篇~
