
本文授權轉載,作者:@景銘巴巴
前陣子看了幾個開源專案,發現它們保持執行緒同步的方式各異:@synchronized、NSLock、dispatch_semaphore、NSCondition、pthread_mutex、OSSpinLock 都有人用。查資料之後才知道,這些機制的實作原理不同,效能差距也很大。不好意思,我們平常用得最多的 @synchronized,恰好是效能最差的那一個。下面先分別說明各個加鎖方式的使用方法,再用同一個案例做效能對比。
NSObject *obj = [[NSObject alloc] init];
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
@synchronized(obj) {
NSLog(@"需要線程同步的操作1 開始");
sleep(3);
NSLog(@"需要線程同步的操作1 結束");
}
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
sleep(1);
@synchronized(obj) {
NSLog(@"需要線程同步的操作2");
}
});@synchronized(obj) 中的 obj 是這把鎖的唯一標識,只有標識相同才會互斥。若把執行緒 2 中的 @synchronized(obj) 改成 @synchronized(self),執行緒 2 就不會被阻塞了。
這個指令的優點是我們不必顯式建立鎖物件就能實作互斥;但作為一種預防措施,@synchronized 區塊會隱式加上一個例外處理常式來保護程式碼,在拋出例外時自動釋放互斥鎖。如果你不希望這層隱式例外處理帶來額外開銷,可以考慮改用明確的鎖物件。
執行結果:
2016-06-29 20:48:35.747 SafeMultiThread[35945:580107] 需要線程同步的操作1 開始 2016-06-29 20:48:38.748 SafeMultiThread[35945:580107] 需要線程同步的操作1 結束 2016-06-29 20:48:38.749 SafeMultiThread[35945:580118] 需要線程同步的操作2
dispatch_semaphore_t signal = dispatch_semaphore_create(1);
dispatch_time_t overTime = dispatch_time(DISPATCH_TIME_NOW, 3 * NSEC_PER_SEC);
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
dispatch_semaphore_wait(signal, overTime);
NSLog(@"需要線程同步的操作1 開始");
sleep(2);
NSLog(@"需要線程同步的操作1 結束");
dispatch_semaphore_signal(signal);
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
sleep(1);
dispatch_semaphore_wait(signal, overTime);
NSLog(@"需要線程同步的操作2");
dispatch_semaphore_signal(signal);
});dispatch_semaphore 是 GCD 提供的同步方式,相關函式共三個:dispatch_semaphore_create、dispatch_semaphore_signal、dispatch_semaphore_wait。
(1)dispatch_semaphore_create 的宣告為:
dispatch_semaphore_t dispatch_semaphore_create(long value);
傳入參數為 long,輸出一個值為 value 的 dispatch_semaphore_t 型別信號量。值得注意的是,傳入的 value 必須大於或等於 0,否則會回傳 NULL。
(2)dispatch_semaphore_signal 的宣告為:
long dispatch_semaphore_signal(dispatch_semaphore_t dsema);
這個函式會把傳入的信號量 dsema 的值加 1。
(3)dispatch_semaphore_wait 的宣告為:
long dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout);
這個函式會把信號量 dsema 的值減 1。它的行為是:若 dsema 的值大於 0,當前執行緒繼續往下執行並將值減 1;若 dsema 的值為 0,則阻塞當前執行緒等待 timeout(注意 timeout 的型別是 dispatch_time_t,不能直接傳入整數或浮點數)。若在等待期間 dsema 被 dispatch_semaphore_signal 加 1,且該執行緒取得了信號量,就繼續往下執行並將值減 1;若等待期間一直取不到信號量,等到 timeout 時執行緒會自動往後執行。
dispatch_semaphore 本質是信號量,但當總量設為 1 時也可以當鎖來用。在沒有等待發生的情況下,它的效能甚至比 pthread_mutex 更高;但一旦出現等待,效能就會下降不少。相對於 OSSpinLock,它的優勢在於等待時不會消耗 CPU 資源。
如上的程式碼,若超時時間 overTime 設為大於 2 秒,可以完成同步;若小於 2 秒,執行緒 1 尚未結束時就已超時,此時會直接往下執行。
執行結果:
2016-06-29 20:47:52.324 SafeMultiThread[35945:579032] 需要線程同步的操作1 開始 2016-06-29 20:47:55.325 SafeMultiThread[35945:579032] 需要線程同步的操作1 結束 2016-06-29 20:47:55.326 SafeMultiThread[35945:579033] 需要線程同步的操作2
把超時設為小於 2 秒時,結果變成:
2016-06-30 18:53:24.049 SafeMultiThread[30834:434334] 需要線程同步的操作1 開始 2016-06-30 18:53:25.554 SafeMultiThread[30834:434332] 需要線程同步的操作2 2016-06-30 18:53:26.054 SafeMultiThread[30834:434334] 需要線程同步的操作1 結束
NSLock *lock = [[NSLock alloc] init];
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// [lock lock];
[lock lockBeforeDate:[NSDate date]];
NSLog(@"需要線程同步的操作1 開始");
sleep(2);
NSLog(@"需要線程同步的操作1 結束");
[lock unlock];
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
sleep(1);
if ([lock tryLock]) { // 嘗試獲取鎖,如果獲取不到返回 NO,不會阻塞該執行緒
NSLog(@"鎖可用的操作");
[lock unlock];
} else {
NSLog(@"鎖不可用的操作");
}
NSDate *date = [[NSDate alloc] initWithTimeIntervalSinceNow:3];
if ([lock lockBeforeDate:date]) { // 嘗試在未來 3s 內獲取鎖,並阻塞該執行緒;3s 內取不到則返回 NO
NSLog(@"沒有超時,獲得鎖");
[lock unlock];
} else {
NSLog(@"超時,沒有獲得鎖");
}
});NSLock 是 Cocoa 提供的最基礎鎖物件,也是最常用的。除了 lock 與 unlock,NSLock 還提供 tryLock 與 lockBeforeDate: 兩個方法:前者嘗試加鎖,若鎖已被佔用則不阻塞執行緒並回傳 NO;後者會在指定時間之前嘗試加鎖,若到期仍取不到則回傳 NO。
執行結果:
2016-06-29 20:45:08.864 SafeMultiThread[35911:575795] 需要線程同步的操作1 開始 2016-06-29 20:45:09.869 SafeMultiThread[35911:575781] 鎖不可用的操作 2016-06-29 20:45:10.869 SafeMultiThread[35911:575795] 需要線程同步的操作1 結束 2016-06-29 20:45:10.870 SafeMultiThread[35911:575781] 沒有超時,獲得鎖
源碼定義如下:
@protocol NSLocking
- (void)lock;
- (void)unlock;
@end
@interface NSLock : NSObject {
@private
void *_priv;
}
- (BOOL)tryLock;
- (BOOL)lockBeforeDate:(NSDate *)limit;
@property (nullable, copy) NSString *name NS_AVAILABLE(10_5, 2_0);
@end// NSLock *lock = [[NSLock alloc] init];
NSRecursiveLock *lock = [[NSRecursiveLock alloc] init];
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
static void (^RecursiveMethod)(int);
RecursiveMethod = ^(int value) {
[lock lock];
if (value > 0) {
NSLog(@"value = %d", value);
sleep(1);
RecursiveMethod(value - 1);
}
[lock unlock];
};
RecursiveMethod(5);
});NSRecursiveLock 實作的是一個遞歸鎖,同一個執行緒可以重複請求而不會造成死鎖,主要用在迴圈或遞歸操作中。
上面這段程式碼若改用 NSLock,就是典型的死鎖:RecursiveMethod 是遞歸呼叫,每次進入 block 都會再 lock 一次,而從第二次開始鎖已被佔用且未解開,於是無限等待。除錯器會輸出:
2016-06-30 19:08:06.393 SafeMultiThread[30928:449008] value = 5 2016-06-30 19:08:07.399 SafeMultiThread[30928:449008] -[NSLock lock]: deadlock ( '(null)' ) 2016-06-30 19:08:07.399 SafeMultiThread[30928:449008] Break on _NSLockError() to debug.
改用 NSRecursiveLock 即可正常執行。遞歸鎖會追蹤它被 lock 的次數,每次成功的 lock 都必須有一次對應的 unlock,只有全部配平之後鎖才會真正釋放,供其他執行緒使用。
執行結果:
2016-06-30 19:09:41.414 SafeMultiThread[30949:450684] value = 5 2016-06-30 19:09:42.418 SafeMultiThread[30949:450684] value = 4 2016-06-30 19:09:43.419 SafeMultiThread[30949:450684] value = 3 2016-06-30 19:09:44.424 SafeMultiThread[30949:450684] value = 2 2016-06-30 19:09:45.426 SafeMultiThread[30949:450684] value = 1
源碼定義:
@interface NSRecursiveLock : NSObject {
@private
void *_priv;
}
- (BOOL)tryLock;
- (BOOL)lockBeforeDate:(NSDate *)limit;
@property (nullable, copy) NSString *name NS_AVAILABLE(10_5, 2_0);
@endNSMutableArray *products = [NSMutableArray array];
NSInteger HAS_DATA = 1;
NSInteger NO_DATA = 0;
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
while (1) {
[lock lockWhenCondition:NO_DATA];
[products addObject:[[NSObject alloc] init]];
NSLog(@"produce a product, 總量:%zi", products.count);
[lock unlockWithCondition:HAS_DATA];
sleep(1);
}
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
while (1) {
NSLog(@"wait for product");
[lock lockWhenCondition:HAS_DATA];
[products removeObjectAtIndex:0];
NSLog(@"custome a product");
[lock unlockWithCondition:NO_DATA];
}
});使用多執行緒時,一把只能 lock/unlock 的鎖未必足夠。普通鎖只在意「鎖了沒」,不在意用哪把鑰匙開鎖;但處理資源共享時,往往是「滿足特定條件才能開鎖」。
上例中執行緒 1 用的是 lock,不需要條件,所以順利鎖住;但它 unlock 時帶了一個整數條件,可以喚醒其他執行緒中正在等待這把鑰匙的臨界區。執行緒 2 則需要標識為 HAS_DATA 的鑰匙,因此直到執行緒 1 最後一次循環,才打開執行緒 2 的阻塞。即便如此,NSConditionLock 與其他鎖一樣需要 lock 與 unlock 配對,只是 lock/lockWhenCondition: 與 unlock/unlockWithCondition: 之間可以自由組合,具體取決於你的需求。
執行結果:
2016-06-30 20:31:58.699 SafeMultiThread[31282:521698] wait for product 2016-06-30 20:31:58.699 SafeMultiThread[31282:521708] produce a product, 總量:1 2016-06-30 20:31:58.700 SafeMultiThread[31282:521698] custome a product 2016-06-30 20:31:58.700 SafeMultiThread[31282:521698] wait for product 2016-06-30 20:31:59.705 SafeMultiThread[31282:521708] produce a product, 總量:1 2016-06-30 20:31:59.706 SafeMultiThread[31282:521698] custome a product
源碼定義:
@interface NSConditionLock : NSObject {
@private
void *_priv;
}
- (instancetype)initWithCondition:(NSInteger)condition NS_DESIGNATED_INITIALIZER;
@property (readonly) NSInteger condition;
- (void)lockWhenCondition:(NSInteger)condition;
- (BOOL)tryLock;
- (BOOL)tryLockWhenCondition:(NSInteger)condition;
- (void)unlockWithCondition:(NSInteger)condition;
- (BOOL)lockBeforeDate:(NSDate *)limit;
- (BOOL)lockWhenCondition:(NSInteger)condition beforeDate:(NSDate *)limit;
@property (nullable, copy) NSString *name NS_AVAILABLE(10_5, 2_0);
@endNSCondition *condition = [[NSCondition alloc] init];
NSMutableArray *products = [NSMutableArray array];
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
while (1) {
[condition lock];
if ([products count] == 0) {
NSLog(@"wait for product");
[condition wait];
}
[products removeObjectAtIndex:0];
NSLog(@"custome a product");
[condition unlock];
}
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
while (1) {
[condition lock];
[products addObject:[[NSObject alloc] init]];
NSLog(@"produce a product, 總量:%zi", products.count);
[condition signal];
[condition unlock];
sleep(1);
}
});這是最基本的條件鎖,由開發者手動控制執行緒的 wait 與 signal。
[condition lock]:多用於多執行緒同時存取、修改同一份資料源的場景,確保同一時間內資料源只被存取一次,其他執行緒的請求會在 lock 之外等待,直到 unlock 才可行動。
[condition unlock]:與 lock 成對使用。
[condition wait]:讓當前執行緒進入等待狀態。
[condition signal]:送訊號通知執行緒不必再等待,可以繼續執行。
執行結果:
2016-06-30 20:21:25.295 SafeMultiThread[31256:513991] wait for product 2016-06-30 20:21:25.296 SafeMultiThread[31256:513994] produce a product, 總量:1 2016-06-30 20:21:25.296 SafeMultiThread[31256:513991] custome a product 2016-06-30 20:21:25.297 SafeMultiThread[31256:513991] wait for product 2016-06-30 20:21:26.302 SafeMultiThread[31256:513994] produce a product, 總量:1 2016-06-30 20:21:26.302 SafeMultiThread[31256:513991] custome a product
__block pthread_mutex_t theLock;
pthread_mutex_init(&theLock, NULL);
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
pthread_mutex_lock(&theLock);
NSLog(@"需要線程同步的操作1 開始");
sleep(3);
NSLog(@"需要線程同步的操作1 結束");
pthread_mutex_unlock(&theLock);
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
sleep(1);
pthread_mutex_lock(&theLock);
NSLog(@"需要線程同步的操作2");
pthread_mutex_unlock(&theLock);
});這是 C 語言層面的多執行緒加鎖方式。
1. pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr):初始化鎖變數 mutex,attr 為鎖屬性,傳 NULL 表示使用預設屬性。
2. pthread_mutex_lock(pthread_mutex_t *mutex):加鎖。
3. pthread_mutex_trylock(pthread_mutex_t *mutex):嘗試加鎖,與 lock 不同的是,若鎖已被使用則回傳 EBUSY,而不是掛起等待。
4. pthread_mutex_unlock(pthread_mutex_t *mutex):釋放鎖。
5. pthread_mutex_destroy(pthread_mutex_t *mutex):使用完畢後銷毀。
執行結果:
2016-06-30 21:13:32.440 SafeMultiThread[31429:548869] 需要線程同步的操作1 開始 2016-06-30 21:13:35.445 SafeMultiThread[31429:548869] 需要線程同步的操作1 結束 2016-06-30 21:13:35.446 SafeMultiThread[31429:548866] 需要線程同步的操作2
__block pthread_mutex_t theLock;
// pthread_mutex_init(&theLock, NULL);
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&lock, &attr);
pthread_mutexattr_destroy(&attr);
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
static void (^RecursiveMethod)(int);
RecursiveMethod = ^(int value) {
pthread_mutex_lock(&theLock);
if (value > 0) {
NSLog(@"value = %d", value);
sleep(1);
RecursiveMethod(value - 1);
}
pthread_mutex_unlock(&theLock);
};
RecursiveMethod(5);
});這是 pthread_mutex 為了避免遞歸情境下死鎖而提供的遞歸鎖,作用與 NSRecursiveLock 類似。若改用 pthread_mutex_init(&theLock, NULL); 初始化,上面的程式碼會死鎖;改用遞歸鎖則沒問題。
__block OSSpinLock theLock = OS_SPINLOCK_INIT;
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
OSSpinLockLock(&theLock);
NSLog(@"需要線程同步的操作1 開始");
sleep(3);
NSLog(@"需要線程同步的操作1 結束");
OSSpinLockUnlock(&theLock);
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
OSSpinLockLock(&theLock);
sleep(1);
NSLog(@"需要線程同步的操作2");
OSSpinLockUnlock(&theLock);
});OSSpinLock 是自旋鎖,效能最高的鎖,原理很簡單:一直 do while 忙等。缺點是等待期間會消耗大量 CPU 資源,因此不適合長時間的任務。此外也有探討指出 OSSpinLock 已不再是安全的選擇,請謹慎使用。
對以上各個鎖進行 1,000,000 次加鎖/解鎖的空操作,耗時如下:
OSSpinLock: 46.15 ms dispatch_semaphore: 56.50 ms pthread_mutex: 178.28 ms NSCondition: 193.38 ms NSLock: 175.02 ms pthread_mutex(recursive): 172.56 ms NSRecursiveLock: 157.44 ms NSConditionLock: 490.04 ms @synchronized: 371.17 ms
總結:
OSSpinLock 與 dispatch_semaphore 的效率遠高於其他選項。
@synchronized 與 NSConditionLock 效率較差。
考量到 OSSpinLock 的安全性問題,若在意效能,建議採用 dispatch_semaphore;若不在意效能、只求寫起來方便,那用 @synchronized 也無妨。