Java並發編程之同步容器
簡介
同步容器主要分兩類,一種是Vector這樣的普通類,一種是通過Collections的工廠方法創建的內部類
雖然很多人都對同步容器的性能低有偏見,但它也不是一無是處,在這裡我們插播一條阿裡巴巴的開發手冊規范:
高並發時,同步調用應該去考量鎖的性能損耗。能用無鎖數據結構,就不要用鎖;能鎖區塊,就不要鎖整個方法體;能用對象鎖,就不要用類鎖。
可以看到,隻有在高並發才會考慮到鎖的性能問題,所以在一些小而全的系統中,同步容器還是有用武之地的(當然也可以考慮並發容器,後面章節再討論)
一、什麼是同步容器
定義:就是把容器類同步化,這樣我們在並發中使用容器時,就不用手動同步,因為內部已經自動同步瞭
例子:比如Vector就是一個同步容器類,它的同步化就是把內部的所有方法都上鎖(有的重載方法沒上鎖,但是最終調用的方法還是有鎖的)
源碼:Vector.add
// 通過synchronized為add方法上鎖 public synchronized boolean add(E e) { modCount++; ensureCapacityHelper(elementCount + 1); elementData[elementCount++] = e; return true; }
同步容器主要分兩類:
1.普通類:Vector、Stack、HashTable
2.內部類:Collections創建的內部類,比如Collections.SynchronizedList、 Collections.SynchronizedSet等
那這兩種有沒有區別呢?
當然是有的,剛開始的時候(Java1.0)隻有第一種同步容器(Vector等)
但是因為Vector這種類太局氣瞭,它就想著把所有的東西都弄過來自己搞(Vector通過toArray轉為己有,HashTable通過putAll轉為己有);
源碼:Vector構造函數
public Vector(Collection<? extends E> c) { // 這裡通過toArray將傳來的集合 轉為己有 elementData = c.toArray(); elementCount = elementData.length; // c.toArray might (incorrectly) not return Object[] (see 6260652) if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, elementCount, Object[].class); }
所以就有瞭第二種同步容器類(通過工廠方法創建的內部容器類),它就比較聰明瞭,它隻是把原有的容器進行包裝(通過this.list = list直接指向需要同步的容器),然後局部加鎖,這樣一來,即生成瞭線程安全的類,又不用太費力;
源碼:Collections.SynchronizedList構造函數
SynchronizedList(List<E> list) { super(list); // 這裡隻是指向傳來的list,不轉為己有,後面的相關操作還是基於原有的list集合 this.list = list; }
他們之間的區別如下:
兩種同步容器的區別 | 普通類 | 內部類 |
鎖的對象 | 不可指定,隻能this | 可指定,默認this |
鎖的范圍 | 方法體(包括迭代) | 代碼塊(不包括迭代) |
適用范圍 | 窄-個別容器 | 廣-所有容器 |
這裡我們重點說下鎖的對象:
- 普通類鎖的是當前對象this(鎖在方法上,默認this對象);
- 內部類鎖的是mutex屬性,這個屬性默認是this,但是可以通過構造函數(或工廠方法)來指定鎖的對象
源碼:Collections.SynchronizedCollection構造函數
final Collection<E> c; // Backing Collection // 這個就是鎖的對象 final Object mutex; // Object on which to synchronize SynchronizedCollection(Collection<E> c) { this.c = Objects.requireNonNull(c); // 初始化為 this mutex = this; } SynchronizedCollection(Collection<E> c, Object mutex) { this.c = Objects.requireNonNull(c); this.mutex = Objects.requireNonNull(mutex); }
這裡要註意一點就是,內部類的迭代器沒有同步(Vector的迭代器有同步),需要手動加鎖來同步
源碼:Vector.Itr.next 迭代方法(有上鎖)
public E next() { synchronized (Vector.this) { checkForComodification(); int i = cursor; if (i >= elementCount) throw new NoSuchElementException(); cursor = i + 1; return elementData(lastRet = i); } }
源碼:Collections.SynchronizedCollection.iterator 迭代器(沒上鎖)
public Iterator<E> iterator() { // 這裡會直接實現類的迭代器(比如ArrayList,它裡面的迭代器肯定是沒上鎖的) return c.iterator(); // Must be manually synched by user! }
二、為什麼要有同步容器
因為普通的容器類(比如ArrayList)是線程不安全的,如果是在並發中使用,我們就需要手動對其加鎖才會安全,這樣的話就很麻煩;
所以就有瞭同步容器,它來幫我們自動加鎖
下面我們用代碼來對比下
線程不安全的類:ArrayList
public class SyncCollectionDemo { private List<Integer> listNoSync; public SyncCollectionDemo() { this.listNoSync = new ArrayList<>(); } public void addNoSync(int temp){ listNoSync.add(temp); } public static void main(String[] args) throws InterruptedException { SyncCollectionDemo demo = new SyncCollectionDemo(); // 創建10個線程 for (int i = 0; i < 10; i++) { // 每個線程執行100次添加操作 new Thread(()->{ for (int j = 0; j < 1000; j++) { demo.addNoSync(j); } }).start(); } } }
上面的代碼看似沒問題,感覺就算有問題也應該是插入的順序比較亂(多線程交替插入)
但實際上運行會發現,可能會報錯數組越界,如下所示:
原因有二:
因為ArrayList.add操作沒有加鎖,導致多個線程可以同時執行add操作add操作時,如果發現list的容量不足,會進行擴容,但是由於多個線程同時擴容,就會出現擴容不足的問題
源碼:ArrayList.grow擴容
// 擴容方法 private void grow(int minCapacity) { // overflow-conscious code int oldCapacity = elementData.length; // 這裡可以看到,每次擴容增加一半的容量 int newCapacity = oldCapacity + (oldCapacity >> 1); if (newCapacity - minCapacity < 0) newCapacity = minCapacity; if (newCapacity - MAX_ARRAY_SIZE > 0) newCapacity = hugeCapacity(minCapacity); // minCapacity is usually close to size, so this is a win: elementData = Arrays.copyOf(elementData, newCapacity); }
可以看到,擴容是基於之前的容量進行的,因此如果多個線程同時擴容,那擴容基數就不準確瞭,結果就會有問題
線程安全的類:Collections.SynchronizedList
/** * <p> * 同步容器類:為什麼要有它 * </p> * * @author: JavaLover * @time: 2021/5/3 */ public class SyncCollectionDemo { private List<Integer> listSync; public SyncCollectionDemo() { // 這裡包裝一個空的ArrayList this.listSync = Collections.synchronizedList(new ArrayList<>()); } public void addSync(int j){ // 內部是同步操作: synchronized (mutex) {return c.add(e);} listSync.add(j); } public static void main(String[] args) throws InterruptedException { SyncCollectionDemo demo = new SyncCollectionDemo(); for (int i = 0; i < 10; i++) { new Thread(()->{ for (int j = 0; j < 100; j++) { demo.addSync(j); } }).start(); } TimeUnit.SECONDS.sleep(1); // 輸出1000 System.out.println(demo.listSync.size()); } }
輸出正確,因為現在ArrayList被Collections包裝成瞭一個線程安全的類
這就是為啥會有同步容器的原因:因為同步容器使得並發編程時,線程更加安全
三、同步容器的優缺點
一般來說,都是先說優點,再說缺點
但是我們這次先說優點
優點:
- 並發編程中,獨立操作是線程安全的,比如單獨的add操作
缺點(是的,優點已經說完瞭):
- 性能差,基本上所有方法都上鎖,完美的詮釋瞭“寧可錯殺一千,不可放過一個”
- 復合操作,還是不安全,比如putIfAbsent操作(如果沒有則添加)
- 快速失敗機制,這種機制會報錯提示
ConcurrentModificationException
,一般出現在當某個線程在遍歷容器時,其他線程恰好修改瞭這個容器的長度
為啥第三點是缺點呢?
因為它隻能作為一個建議,告訴我們有並發修改異常,但是不能保證每個並發修改都會爆出這個異常
爆出這個異常的前提如下:
源碼:Vector.Itr.checkForComodification 檢查容器修改次數
final void checkForComodification() { // modCount:容器的長度變化次數, expectedModCount:期望的容器的長度變化次數 if (modCount != expectedModCount) throw new ConcurrentModificationException(); }
那什麼情況下並發修改不會爆出異常呢?有兩種:
1.遍歷沒加鎖的情況:對於第二種同步容器(Collections內部類)來說,假設線程A修改瞭modCount的值,但是沒有同步到線程B,那麼線程B遍歷就不會發生異常(但實際上問題已經存在瞭,隻是暫時沒有出現)
2.依賴線程執行順序的情況:對於所有的同步容器來說,假設線程B已經遍歷完瞭容器,此時線程A才開始遍歷修改,那麼也不會發生異常
代碼就不貼瞭,大傢感興趣的可以直接寫幾個線程遍歷試試,多運行幾次,應該就可以看到效果(不過第一種情況也是基於理論分析,實際代碼我這邊也沒跑出來)
根據阿裡巴巴的開發規范:不要在 foreach 循環裡進行元素的 remove/add 操作。remove 元素請使用 Iterator方式,如果並發操作,需要對 Iterator 對象加鎖。
這裡解釋下,關於List.remove和Iterator.remove的區別
- Iterator.remove:會同步修改expectedModCount=modCount
- list.remove:隻會修改modCount,因為expectedModCount屬於iterator對象的屬性,不屬於list的屬性(但是也可以間接訪問)
源碼:ArrayList.remove移除元素操作
public E remove(int index) { rangeCheck(index); // 1. 這裡修改瞭 modCount modCount++; E oldValue = elementData(index); int numMoved = size - 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; }
源碼:ArrayList.Itr.remove迭代器移除元素操作
public void remove() { if (lastRet < 0) throw new IllegalStateException(); checkForComodification(); try { // 1. 這裡調用上面介紹的list.romove,修改modCount ArrayList.this.remove(lastRet); cursor = lastRet; lastRet = -1; // 2. 這裡再同步更新 expectedModCount expectedModCount = modCount; } catch (IndexOutOfBoundsException ex) { throw new ConcurrentModificationException(); } }
由於同步容器的這些缺點,於是就有瞭並發容器(下期來介紹)
四、同步容器的使用場景
多用在並發編程,但是並發量又不是很大的場景,比如一些簡單的個人博客系統(具體多少並發量算大,這個也是分很多情況而論的,並不是說每秒處理超過多少個請求,就說是高並發,還要結合吞吐量、系統響應時間等多個因素一起考慮)
具體點來說的話,有以下幾個場景:
- 寫多讀少,這個時候同步容器和並發容器的性能差別不大(並發容器可以並發讀)
- 自定義的復合操作,比如getLast等操作(putIfAbsent就算瞭,因為並發容器有默認提供這個復合操作)
- 等等
總結
什麼是同步容器:就是把容器類同步化,這樣我們在並發中使用容器時,就不用手動同步,因為內部已經自動同步瞭
為什麼要有同步容器:因為普通的容器類(比如ArrayList)是線程不安全的,如果是在並發中使用,我們就需要手動對其加鎖才會安全,這樣的話就很太麻煩;所以就有瞭同步容器,它來幫我們自動加鎖
同步容器的優缺點:
優點
獨立操作,線程安全
缺點 復合操作,還是不安全,性能差快速失敗機制,隻適合bug調試
同步容器的使用場景
多用在並發量不是很大的場景,比如個人博客、後臺系統等
具體點來說,有以下幾個場景:
- 寫多讀少:這個時候同步容器和並發容器差別不是很大
- 自定義復合操作:比如getLast等復合操作,因為同步容器都是單個操作進行上鎖的,所以可以很方便地去拼接復合操作(記得外部加鎖)
到此這篇關於Java並發編程之同步容器的文章就介紹到這瞭,更多相關Java同步容器內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet!
推薦閱讀:
- Java Vector和ArrayList的異同分析及實例講解
- java數據結構ArrayList詳解
- Java中ArrayList和LinkedList區別
- java中List接口與實現類介紹
- 關於ArrayList的動態擴容機制解讀