您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發基礎

iOS 執行緒安全實作方案與效能對比

編輯:iOS 開發基礎

本文授權轉載,作者:@景銘巴巴

一、前言

前陣子看了幾個開源專案,發現它們保持執行緒同步的方式各異:@synchronized、NSLock、dispatch_semaphore、NSCondition、pthread_mutex、OSSpinLock 都有人用。查資料之後才知道,這些機制的實作原理不同,效能差距也很大。不好意思,我們平常用得最多的 @synchronized,恰好是效能最差的那一個。下面先分別說明各個加鎖方式的使用方法,再用同一個案例做效能對比。

二、介紹與使用

2.1 @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

2.2 dispatch_semaphore

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 結束

2.3 NSLock

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

2.4 NSRecursiveLock 遞歸鎖

// 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);
@end

2.5 NSConditionLock 條件鎖

NSMutableArray *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);
@end

2.6 NSCondition

NSCondition *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

2.7 pthread_mutex

__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

2.8 pthread_mutex(recursive)

__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); 初始化,上面的程式碼會死鎖;改用遞歸鎖則沒問題。

2.9 OSSpinLock

__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 也無妨。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved