iOS中保證執行緒安全的幾種方式與效能對比

發表於2016-07-10

一、前言

前段時間看了幾個開源專案，發現他們保持執行緒同步的方式各不相同，有@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");
        }
    });

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指令實現鎖的優點就是我們不需要在程式碼中顯式的建立鎖物件，便可以實現鎖的機制，但作為一種預防措施，@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_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，輸出一個dispatch_semaphore_t型別且值為value的訊號量。

值得注意的是，這裡的傳入的引數value必須大於或等於0，否則dispatch_semaphore_create會返回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；如果desema的值為0，那麼這個函式就阻塞當前執行緒等待timeout（注意timeout的型別為dispatch_time_t，不能直接傳入整形或float型數），如果等待的期間desema的值被dispatch_semaphore_signal函式加1了，且該函式（即dispatch_semaphore_wait）所處執行緒獲得了訊號量，那麼就繼續向下執行並將訊號量減1。如果等待期間沒有獲取到訊號量或者訊號量的值一直為0，那麼等到timeout時，其所處執行緒自動執行其後語句。

dispatch_semaphore 是訊號量，但當訊號總量設為 1 時也可以當作鎖來。在沒有等待情況出現時，它的效能比 pthread_mutex 還要高，但一旦有等待情況出現時，效能就會下降許多。相對於 OSSpinLock 來說，它的優勢在於等待時不會消耗 CPU 資源。

如上的程式碼，如果超時時間overTime設定成>2，可完成同步操作。如果overTime

上面程式碼的執行結果為：

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

如果把超時時間設定為

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 *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。lockBeforeDate:方法會在所指定Date之前嘗試加鎖，如果在指定時間之前都不能加鎖，則返回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  {
<a href="http://www.jobbole.com/members/kaishu6296">@private</a>
    void *_priv;
}

- (BOOL)tryLock;
- (BOOL)lockBeforeDate:(NSDate *)limit;

@property (nullable, copy) NSString *name NS_AVAILABLE(10_5, 2_0);

@end

@protocol NSLocking

- (void)lock;

- (void)unlock;

@end

@interface NSLock : NSObject {

<a href="http://www.jobbole.com/members/kaishu6296">@private</a>

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);
    });

//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實際上定義的是一個遞迴鎖，這個鎖可以被同一執行緒多次請求，而不會引起死鎖。這主要是用在迴圈或遞迴操作中。

這段程式碼是一個典型的死鎖情況。在我們的執行緒中，RecursiveMethod是遞迴呼叫的。所以每次進入這個block時，都會去加一次鎖，而從第二次開始，由於鎖已經被使用了且沒有解鎖，所以它需要等待鎖被解除，這樣就導致了死鎖，執行緒被阻塞住了。偵錯程式中會輸出如下資訊：

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操作。只有所有達到這種平衡，鎖最後才能被釋放，以供其它執行緒使用。

如果我們將NSLock代替為NSRecursiveLock，上面程式碼則會正確執行。

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  {
<a href="http://www.jobbole.com/members/kaishu6296">@private</a>
    void *_priv;
}

- (BOOL)tryLock;
- (BOOL)lockBeforeDate:(NSDate *)limit;

@property (nullable, copy) NSString *name NS_AVAILABLE(10_5, 2_0);

@end

@interface NSRecursiveLock : NSObject {

<a href="http://www.jobbole.com/members/kaishu6296">@private</a>

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];
        }

    });

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則需要一把被標識為2的鑰匙，所以當執行緒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
2016-06-30 20:31:59.706 SafeMultiThread[31282:521698] wait for product
2016-06-30 20:32:00.707 SafeMultiThread[31282:521708] produce a product,總量:1
2016-06-30 20:32:00.708 SafeMultiThread[31282:521698] custome a product

如果你需要其他功能，原始碼定義如下：

@interface NSConditionLock : NSObject  {
<a href="http://www.jobbole.com/members/kaishu6296">@private</a>
    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

@interface NSConditionLock : NSObject {

<a href="http://www.jobbole.com/members/kaishu6296">@private</a>

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);
        }

    });

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];CPU發訊號告訴執行緒不用在等待，可以繼續執行

上面程式碼執行結果如下：

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
2016-06-30 20:21:26.302 SafeMultiThread[31256:513991] wait for product
2016-06-30 20:21:27.307 SafeMultiThread[31256:513994] produce a product,總量:1
2016-06-30 20:21:27.308 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);

    });

__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_tylock(*pthread_mutex_t *mutex);加鎖，但是與2不一樣的是當鎖已經在使用的時候，返回為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);
    });

__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);

});

__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 資源，所以它不適用於較長時間的任務。不過最近YY大神在自己的部落格不再安全的 OSSpinLock中說明了OSSpinLock已經不再安全，請大家謹慎使用。

三、效能對比

對以上各個鎖進行1000000此的加鎖解鎖的空操作時間如下：

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。

四、聯絡方式

新浪微博
 github
簡書首頁
歡迎加好友、一起交流。

Java多執行緒之—Synchronized方式和CAS方式實現執行緒安全效能對比
2018-09-18
Java執行緒synchronized
執行緒池建立的幾種方式
2024-08-15
執行緒
java--執行緒池--建立執行緒池的幾種方式與執行緒池操作詳解
2021-07-13
Java執行緒
iOS多執行緒安全-13種執行緒鎖?
2018-11-19
iOS執行緒
執行緒池的五種狀態及建立執行緒池的幾種方式
2020-10-30
執行緒
Map實現執行緒安全的3種方式
2019-03-07
執行緒
Java建立多執行緒的幾種方式實現
2020-10-27
Java執行緒
c# 多執行緒的幾種方式【轉載】
2024-05-07
C#執行緒
面試必問－幾種執行緒安全的Map解析
2017-08-13
面試執行緒
Java多執行緒13：讀寫鎖和兩種同步方式的對比
2015-10-05
Java執行緒
獲取Java執行緒返回值的幾種方式
2019-02-20
Java執行緒
多執行緒-多執行緒兩種方式的圖解比較及區別
2017-06-03
執行緒圖解
幀動畫的多種實現方式與效能對比
2019-03-05
動畫
iOS 多執行緒之執行緒安全
2019-01-24
iOS執行緒
iOS多執行緒之執行緒安全
2017-08-29
iOS執行緒
Kubernetes 幾種儲存方式效能對比（轉載）
2019-12-11
執行緒的幾種狀態
2017-05-07
執行緒
建立執行緒的三種方式
2019-02-28
執行緒
執行緒建立的四種方式
2018-03-06
執行緒
【多執行緒高併發程式設計】二實現多執行緒的幾種方式
2020-05-08
執行緒程式設計
Java之執行緒安全問題的3種處理方式（通過執行緒同步）
2018-08-28
Java執行緒
iOS 在主執行緒操作UI不能保證安全
2018-10-15
iOS執行緒UI
執行緒、開啟執行緒的兩種方式、執行緒下的Join方法、守護執行緒
2024-06-25
執行緒
Java中實現執行緒安全HashSet的幾種方法 | baeldung
2022-01-27
Java執行緒
Java中確保執行緒安全最常用的兩種方式
2018-09-02
Java執行緒
幾種簡潔建立執行緒的方式以及使用注意事項
2018-12-11
執行緒
Java提供的幾種執行緒池
2019-07-25
Java執行緒
JAVA 執行緒的幾種狀態
2010-03-30
Java執行緒
【java】【多執行緒】建立執行緒的兩種常用方式（2）
2018-04-15
Java執行緒
java執行緒建立的兩種方式
2016-11-30
Java執行緒
java建立執行緒池的幾中方式
2024-07-18
Java執行緒
面試官問我：建立執行緒有幾種方式？我笑了
2020-10-24
面試執行緒
Java執行緒(一)：執行緒安全與不安全
2021-12-05
Java執行緒
PHP的執行緒安全與非執行緒安全版本的區別
2011-12-30
PHP執行緒
保證執行緒安全的技術
2023-05-08
執行緒
java 多執行緒之使用 interrupt 停止執行緒的幾種方法
2018-09-18
Java執行緒
iOS開發基礎——執行緒安全（執行緒鎖）
2019-02-19
iOS執行緒
【.NET 6】多執行緒的幾種開啟方式和程式碼演示
2022-06-19
執行緒

iOS中保證執行緒安全的幾種方式與效能對比

二、介紹與使用

2.1、@synchronized

2.2、dispatch_semaphore

2.3、NSLock

2.4、NSRecursiveLock遞迴鎖

2.5、NSConditionLock條件鎖

2.6、NSCondition

2.7、pthread_mutex

2.8、pthread_mutex(recursive)

2.9、OSSpinLock

三、效能對比

四、聯絡方式

相關文章