iOS 选择最合适的锁

OSSpinLock - 放弃使用

原理：忙等(busy-wait),消耗大量CPU时间

#include 
OSSpinLock _ossLock = OS_SPINLOCK_INIT;
OSSpinLockLock(&_ossLock);
OSSpinLockUnlock(&_ossLock);

OSSpinLock在加锁解锁的速度方面，表现最好，但安全性难以保证。
原因：低优先级线程拿到锁时，高优先级线程进入忙等状态，消耗大量CPU时间，导致低优先级线程拿不到CUP时间，也无法完成任务释放锁。这种现象被称为优先级反转。
操作系统管理线程，通常采用时间片轮转算法。一个时间片(10-100毫秒)，当线程用完属于自己的时间片后，会被操作系统挂起，放入等待队列中，直到下一次分配时间。

pthread_mutex - 推荐使用

原理：阻塞线程并睡眠，需要频繁的进行线程切换
互斥锁

pthread_mutex_t   _mutex;
pthread_mutex_init(&_mutex, NULL);

递归锁

pthread_mutexattr_t attr;  
pthread_mutexattr_init(&attr);  
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); 

pthread_mutex_t   _mutex;
pthread_mutex_init(&_mutex, &attr);

两者加锁解锁代码一样

pthread_mutex_lock(&_mutex);
pthread_mutex_unlock(&_mutex);

dispatch_semaphore - 可配合GCD执行串行任务

dispatch_semaphore_t _semaphore = dispatch_semaphore_create(1); //创建
dispatch_semaphore_wait(_semaphore, DISPATCH_TIME_FOREVER);
//code
dispatch_semaphore_signal(_semaphore);

创建时的参数必须大于0，否则dispatch_semaphore_t会为NULL.
dispatch_semaphore_wait 判断信号值，小于等于0，阻塞线程。大于0，直接执行code,同时dispatch_semaphore_wait使信号值减一。
dispatch_semaphore_signal 调用后，信号值又会加一。
若果信号值等于10，意味着code可能同时被10个线程访问。

OC 层面的锁

synchronized - 性能较差

原理：把对象当做锁来使用，传入nil等效于不加锁

@synchronized (obj) {
        //code
  }

NSLock - 内部封装了pthread_mutex

NSLock *lock = [NSLock lock];
[lock lock];  //加锁
[lock unlock]; //解锁

NSRecursiveLock - 递归锁

可以被同一线程多次加锁，而不造成死锁。记录lock次数，调用同等次数的unlock,锁最后才能被释放。其他线程才可以开始使用。

NSRecursiveLock *_recursiveLock = [[NSRecursiveLock alloc]init];
[self testRecursiveLock];
-(void)testRecursiveLock {
   
    [_recursiveLock lock];
    static int a = 1;
    if(a < 100){
        a++;
        [self testRecursiveLock];
    }
    [_recursiveLock unlock];
}

NSConditionLock - 条件锁

NSConditionLock *lock = [[NSConditionLock alloc] initWithCondition:0];
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        
        [lock lockWhenCondition:1];
        NSLog(@"线程1");
        [lock unlockWithCondition:3];
    });

    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        
        [lock lockWhenCondition:0];
        NSLog(@"线程2");
        sleep(2);
        [lock unlockWithCondition:1];
    });

打印结果: 线程2、线程1
原因: 条件的初始值是0，
线程1 [lock lockWhenCondition:1]; 不满足，阻塞。
线程2 [lock lockWhenCondition:0]; 满足，执行 NSLog(@"线程2");然后解锁的同时把条件置为1。线程1满足执行条件。

NSCondition - 递归+条件

 NSCondition *lock = [[NSCondition alloc] init];
    NSMutableArray *array = [[NSMutableArray alloc] init];
    //线程1
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [lock lock];
        while (!array.count) {
            NSLog(@"wait");
            [lock wait];
        }
        [array removeAllObjects];
        NSLog(@"array removeAllObjects");
        [lock unlock];
    });
    
    //线程2
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        sleep(1);//以保证让线程2的代码后执行
        [lock lock];
        [array addObject:@1];
        NSLog(@"array addObject:@1");
        [lock signal];
        [lock unlock];
    });

锁上之后，其他线程还能上锁。wait 方法进行阻塞。其它线程中的该锁执行 signal 或者 broadcast 方法时，线程被唤醒。如果没有等待的线程，则两个方法都不起用。