Java並發-同步容器篇

作者:湯圓

個人部落格:javalover.cc

前言

官人們好啊,我是湯圓,今天給大家帶來的是《Java並發-同步容器篇》,希望有所幫助,謝謝

文章如果有問題,歡迎大家批評指正,在此謝過啦

簡介

同步容器主要分兩類,一種是Vector這樣的普通類,一種是通過Collections的工廠方法創建的內部類

雖然很多人都對同步容器的性能低有偏見,但它也不是一無是處,在這裡我們插播一條阿里巴巴的開發手冊規範:

高並發時,同步調用應該去考量鎖的性能損耗。能用無鎖數據結構,就不要用鎖;能鎖區塊,就不要鎖整個方法體;能用對象鎖,就不要用類鎖。

可以看到,只有在高並發才會考慮到鎖的性能問題,所以在一些小而全的系統中,同步容器還是有用武之地的(當然也可以考慮並發容器,後面章節再討論)

附言:這不是洗白貼

目錄

我們這裡分三步來分析:

  1. 什麼是同步容器
  2. 為什麼要有同步容器
  3. 同步容器的優缺點
  4. 同步容器的使用場景

正文

1. 什麼是同步容器

定義:就是把容器類同步化,這樣我們在並發中使用容器時,就不用手動同步,因為內部已經自動同步了

例子:比如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!
}

2. 為什麼要有同步容器

因為普通的容器類(比如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();
        }
    }
}

上面的程式碼看似沒問題,感覺就算有問題也應該是插入的順序比較亂(多執行緒交替插入)

但實際上運行會發現,可能會報錯數組越界,如下所示:

數組越界-執行緒不安全類

原因有二:

  1. 因為ArrayList.add操作沒有加鎖,導致多個執行緒可以同時執行add操作
  2. 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包裝成了一個執行緒安全的類

這就是為啥會有同步容器的原因:因為同步容器使得並發編程時,執行緒更加安全

3. 同步容器的優缺點

一般來說,都是先說優點,再說缺點

但是我們這次先說優點

優點:

  • 並發編程中,獨立操作是執行緒安全的,比如單獨的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();
            }
        }

由於同步容器的這些缺點,於是就有了並發容器(下期來介紹)

4. 同步容器的使用場景

多用在並發編程,但是並發量又不是很大的場景,比如一些簡單的個人部落格系統(具體多少並發量算大,這個也是分很多情況而論的,並不是說每秒處理超過多少個請求,就說是高並發,還要結合吞吐量、系統響應時間等多個因素一起考慮)

具體點來說的話,有以下幾個場景:

  • 寫多讀少,這個時候同步容器和並發容器的性能差別不大(並發容器可以並發讀)
  • 自定義的複合操作,比如getLast等操作(putIfAbsent就算了,因為並發容器有默認提供這個複合操作)
  • 等等

總結

  1. 什麼是同步容器:就是把容器類同步化,這樣我們在並發中使用容器時,就不用手動同步,因為內部已經自動同步了
  2. 為什麼要有同步容器:因為普通的容器類(比如ArrayList)是執行緒不安全的,如果是在並發中使用,我們就需要手動對其加鎖才會安全,這樣的話就很太麻煩;所以就有了同步容器,它來幫我們自動加鎖
  3. 同步容器的優缺點:
優點 缺點
同步容器 獨立操作,執行緒安全 複合操作,還是不安全
性能差
快速失敗機制,只適合bug調試
  1. 同步容器的使用場景

多用在並發量不是很大的場景,比如個人部落格、後台系統等

具體點來說,有以下幾個場景:

  • 寫多讀少:這個時候同步容器和並發容器差別不是很大

  • 自定義複合操作:比如getLast等複合操作,因為同步容器都是單個操作進行上鎖的,所以可以很方便地去拼接複合操作(記得外部加鎖)

  • 等等

參考內容:

  • 《Java並發編程實戰》
  • 《實戰Java高並發》

後記

最後,感謝大家的觀看,謝謝

原創不易,期待官人們的三連喲