怎么檢測項目中的Data race？

下面就進入正題簡單聊一聊iOS中的鎖，以及相關的內容（由于本人能力有限，文中難免有一些遺漏或者錯誤，請各位看官不吝賜教！謝謝！??)

簡單的性能測試

下圖是我針對iOS中的鎖自己測試得出的，圖中數字代表每次加解鎖需要消耗的時間，單位為ns。代碼在這里，代碼參考自YY大神的不再安全的 OSSpinLock，基本跟YY大神的圖差不多??，YY大神的單位是μs，應該是1000次的，或者寫錯了吧~

LockPerformance.jpg

• 注：運行手機： iphone6s plus ，系統版本：11.2.2，Xcode9.2；數字的單位為ns（得出的具體數值是跑了多次取的均值）。

值得注意的是：1.這個數字僅僅代表每次加解鎖的耗時，并不能全方面的代表性能。2.不同的機型和系統，不同的循環次數可能結果會略微有些差異。
但是還是可以看出@synchronized:是表現最差的。

在具體說這些鎖之前，先來說幾個概念定義：(參考維基百科)

1. 臨界區：指的是一塊對公共資源進行訪問的代碼，并非一種機制或是算法。

2. 自旋鎖：是用于多線程同步的一種鎖，線程反復檢查鎖變量是否可用。由于線程在這一過程中保持執行，因此是一種忙等待。一旦獲取了自旋鎖，線程會一直保持該鎖，直至顯式釋放自旋鎖。 自旋鎖避免了進程上下文的調度開銷，因此對于線程只會阻塞很短時間的場合是有效的。

3. 互斥鎖（Mutex）：是一種用于多線程編程中，防止兩條線程同時對同一公共資源（比如全局變量）進行讀寫的機制。該目的通過將代碼切片成一個一個的臨界區而達成。

4. 讀寫鎖：是計算機程序的并發控制的一種同步機制，也稱“共享-互斥鎖”、多讀者-單寫者鎖) 用于解決多線程對公共資源讀寫問題。讀操作可并發重入，寫操作是互斥的。 讀寫鎖通常用互斥鎖、條件變量、信號量實現。

5. 信號量（semaphore）：是一種更高級的同步機制，互斥鎖可以說是semaphore在僅取值0/1時的特例。信號量可以有更多的取值空間，用來實現更加復雜的同步，而不單單是線程間互斥。

6. 條件鎖：就是條件變量，當進程的某些資源要求不滿足時就進入休眠，也就是鎖住了。當資源被分配到了，條件鎖打開，進程繼續運行。

互斥鎖

1.NSLock：是Foundation框架中以對象形式暴露給開發者的一種鎖，（Foundation框架同時提供了NSConditionLock，NSRecursiveLock，NSCondition）NSLock定義如下：

@protocol NSLocking

- (void)lock;
- (void)unlock;

@end

@interface NSLock : NSObject <NSLocking> {
@private
    void *_priv;
}

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

@property (nullable, copy) NSString *name API_AVAILABLE(macos(10.5), ios(2.0), watchos(2.0), tvos(9.0));

@end

tryLock 和 lock 方法都會請求加鎖，唯一不同的是trylock在沒有獲得鎖的時候可以繼續做一些任務和處理。lockBeforeDate方法也比較簡單，就是在limit時間點之前獲得鎖，沒有拿到返回NO。
實際項目中：NSLock在AFNetworking的AFURLSessionManager.m中應用如下：

- (instancetype)initWithSessionConfiguration:(NSURLSessionConfiguration *)configuration {
    ...
    self.lock = [[NSLock alloc] init];
    self.lock.name = AFURLSessionManagerLockName;
    ...
}
- (void)setDelegate:(AFURLSessionManagerTaskDelegate *)delegate
            forTask:(NSURLSessionTask *)task
{
    ...
    [self.lock lock];
    self.mutableTaskDelegatesKeyedByTaskIdentifier[@(task.taskIdentifier)] = delegate;
    [delegate setupProgressForTask:task];
    [self addNotificationObserverForTask:task];
    [self.lock unlock];
}

2.pthread_mutex：
實際項目中： 在YYKit的YYMemoryCach中可以看到

- (instancetype)init {
    ...
    pthread_mutex_init(&_lock, NULL);
    ...
}
- (void)_trimToCost:(NSUInteger)costLimit {
    BOOL finish = NO;
    pthread_mutex_lock(&_lock);
    if (costLimit == 0) {
        [_lru removeAll];
        finish = YES;
    } else if (_lru->_totalCost <= costLimit) {
        finish = YES;
    }
    pthread_mutex_unlock(&_lock);
    if (finish) return;
    
    NSMutableArray *holder = [NSMutableArray new];
    while (!finish) {
        if (pthread_mutex_trylock(&_lock) == 0) {
            if (_lru->_totalCost > costLimit) {
                _YYLinkedMapNode *node = [_lru removeTailNode];
                if (node) [holder addObject:node];
            } else {
                finish = YES;
            }
            pthread_mutex_unlock(&_lock);
        } else {
            usleep(10 * 1000); //10 ms
        }
    }
   ...
}

3.@synchronized:
實際項目中：AFNetworking中 isNetworkActivityOccurring屬性的getter方法

- (BOOL)isNetworkActivityOccurring {
    @synchronized(self) {
        return self.activityCount > 0;
    }
}

關于 @synchronized推薦擴展閱讀 關于 @synchronized，這兒比你想知道的還要多

自旋鎖

1.OSSpinLock:

OSSpinLock lock = OS_SPINLOCK_INIT;
OSSpinLockLock(&lock);
...
OSSpinLockUnlock(&lock);

上面是OSSpinLock使用方式，編譯會報警告，已經廢棄了，OSSpinLock大家也已經不再用它了，因為它在某一些場景下已經不安全了，可以參考 YY大神的不再安全的 OSSpinLock，在Protocol Buffers項目中你可以看到這樣的注釋，大家已經用新的方案替換了。

 // NOTE: OSSpinLock may seem like a good fit here but Apple engineers have
  // pointed out that they are vulnerable to live locking on iOS in cases of
  // priority inversion:
  //   http://mjtsai.com/blog/2015/12/16/osspinlock-is-unsafe/
  //   https://lists.swift.org/pipermail/swift-dev/Week-of-Mon-20151214/000372.html

os_unfair_lock:(互斥鎖)
os_unfair_lock 是蘋果官方推薦的替換OSSpinLock的方案，但是它在iOS10.0以上的系統才可以調用。os_unfair_lock是一種互斥鎖，它不會向自旋鎖那樣忙等，而是等待線程會休眠。

os_unfair_lock_t unfairLock;
unfairLock = &(OS_UNFAIR_LOCK_INIT);
os_unfair_lock_lock(unfairLock);
os_unfair_lock_unlock(unfairLock);

讀寫鎖

上文有說到，讀寫鎖又稱共享-互斥鎖，
pthread_rwlock：

//加讀鎖
pthread_rwlock_rdlock(&rwlock);
//解鎖
pthread_rwlock_unlock(&rwlock);
//加寫鎖
pthread_rwlock_wrlock(&rwlock);
//解鎖
pthread_rwlock_unlock(&rwlock);

遞歸鎖

遞歸鎖有一個特點，就是同一個線程可以加鎖N次而不會引發死鎖。
1.NSRecursiveLock:
NSRecursiveLock在YYKit中YYWebImageOperation.m中有用到：

_lock = [NSRecursiveLock new];
- (void)dealloc {
    [_lock lock];
    ...
    ...
    [_lock unlock];
}

2.pthread_mutex(recursive):
pthread_mutex鎖也支持遞歸，只需要設置PTHREAD_MUTEX_RECURSIVE即可

pthread_mutex_t lock;
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&lock, &attr);
pthread_mutexattr_destroy(&attr);
pthread_mutex_lock(&lock);
pthread_mutex_unlock(&lock);

條件鎖

1. NSCondition:
定義：

@interface NSCondition : NSObject <NSLocking> {
@private
    void *_priv;
}

- (void)wait;
- (BOOL)waitUntilDate:(NSDate *)limit;
- (void)signal;
- (void)broadcast;

遵循NSLocking協議，使用的時候同樣是lock,unlock加解鎖，wait是傻等，waitUntilDate:方法是等一會，都會阻塞掉線程，signal是喚起一個在等待的線程，broadcast是廣播全部喚起。

NSCondition *lock = [[NSCondition alloc] init];
//Son 線程
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    [lock lock];
    while (No Money) {
        [lock wait];
    }
    NSLog(@"The money has been used up.");
    [lock unlock];
});
    
 //Father線程
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    [lock lock];
    NSLog(@"Work hard to make money.");
    [lock signal];
    [lock unlock];
 });

2.NSConditionLock:
定義：

@interface NSConditionLock : NSObject <NSLocking> {
@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;

很簡單，方法很清晰，基本同上。

信號量

dispatch_semaphore:
dispatch_semaphore在YYKit中的YYThreadSafeArray.m有所應用，YY大神有這樣一句注釋：

@discussion Generally, access performance is lower than NSMutableArray, 
 but higher than using @synchronized, NSLock, or pthread_mutex_t.

#define LOCK(...) dispatch_semaphore_wait(_lock, DISPATCH_TIME_FOREVER); \
__VA_ARGS__; \
dispatch_semaphore_signal(_lock);

總結：

其實本文寫的都是一些再基礎不過的內容，在平時閱讀一些開源項目的時候經常會遇到一些保持線程同步的方式，因為場景不同可能選型不同，這篇就做一下簡單的記錄吧~我相信讀完這篇你應該能根據不同場景選擇合適的鎖了吧、能夠道出自旋鎖和互斥鎖的區別了吧。

最后：

由于本人能力有限，文中難免有一些遺漏或者錯誤，請各位看官不吝賜教！謝謝！同時有任何關于鎖相關的疑問可以瘋狂留言，一起交流，一起進步~?? 祝大家每天都能進步一點點~

擴展閱讀：

1. 不再安全的 OSSpinLock????
2. 深入理解 iOS 開發中的鎖????
3. 關于 @synchronized，這兒比你想知道的還要多??????
4. pthread的各種同步機制- Casa Taloyum????
5. Threading Programming Guide