多线程带来的问题之一就是安全问题，“锁”是为了使多个线程间可以相互排斥地使用全局变量等共享资源，简单来说就是保证同一时刻只有一个线程访问一块代码。

下面是一个有安全问题的代码例子：

- (void)test {
    //期望操作
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [self addNum];
    });
    //未预料的操作
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [self addNum];
    });
}

static int i = 0;

- (void)addNum {
    NSLog(@"执行开始 i=%d, 线程：%@", i, [NSThread currentThread]);
    I++;
    [NSThread sleepForTimeInterval:1];  //让线程阻塞一秒
    NSLog(@"执行结束 i=%d, 线程：%@", i, [NSThread currentThread]);
}

你只需要在你的主线程runloop中调用test就能测试了（如果目前看不明白关于线程的操作没关系，这里只是实现两个任务并行，并且模拟延长了addNum这个方法的执行时间），我们看到打印结果：

执行开始 i=0, 线程：<NSThread: 0x600000466140>{number = 5, name = (null)}
执行开始 i=0, 线程：<NSThread: 0x600000466940>{number = 4, name = (null)}
执行结束 i=2, 线程：<NSThread: 0x600000466940>{number = 4, name = (null)}
执行结束 i=2, 线程：<NSThread: 0x600000466140>{number = 5, name = (null)}

看到了么，我们无法预料异常的调用何时开始，我们期望得到的i = 1（我们的期望线程是number=4），然而却不一定能正常得到。所以，我们需要通过技术来实现共享变量的安全读写。

在介绍iOS的几种锁之前，先科普“死锁”的概念。

死锁：多线程等待一个永远无法实现的条件而无法继续执行。

1、NSLock

NSLock的使用非常简单，只需要将需要加锁的代码全部放进lock和unlock方法中。
我们修改上面的addNum代码如下：

//注意lock是一个NSLock类的全局变量lock=[NSLock new]

- (void)addNum {
    [lock lock];
    NSLog(@"执行开始 i=%d, 线程：%@", i, [NSThread currentThread]);
    I++;
    [NSThread sleepForTimeInterval:1];  //让线程阻塞一秒
    NSLog(@"执行结束 i=%d, 线程：%@", i, [NSThread currentThread]);
    [lock unlock];
}

同样运行程序调用test方法，打印如下：

执行开始 i=0, 线程：<NSThread: 0x600000672940>{number = 5, name = (null)}
执行结束 i=1, 线程：<NSThread: 0x600000672940>{number = 5, name = (null)}
执行开始 i=1, 线程：<NSThread: 0x60400047e580>{number = 6, name = (null)}
执行结束 i=2, 线程：<NSThread: 0x60400047e580>{number = 6, name = (null)}

作用一目了然吧，这里我们的期望线程为number=5它完整的走了执行开始和执行结束，而没有受到number=6线程的干扰（因为如果获取不到锁，number=6线程就休眠了）。

注意一：NSLock是基于POSIX线程实现的，lock和unlock都必须在同一个线程执行。
注意二：我们尽量将lock和unlock写在一起，如果业务需要导致获得锁和解锁的逻辑很分散（或者无法判断是否在同一线程），可以调用-(BOOL)tryLock方法尝试能否获取该锁，方便我们做不同的逻辑，代码如下：

- (void)addNum {
    if ([lock tryLock]) {
        NSLog(@"得到锁");
        NSLog(@"执行开始 i=%d, 线程：%@", i, [NSThread currentThread]);
        I++;
        [NSThread sleepForTimeInterval:1];  //让线程阻塞一秒
        NSLog(@"执行结束 i=%d, 线程：%@", i, [NSThread currentThread]);
        [lock unlock];
    } else {
        NSLog(@"没有得到锁");
    }
}

2、NSConditionLock

顾名思义，带条件的锁。同样实现了NSLocking协议，所以它的玩儿法和NSLock很像，而且它有一个方法很有意思。

• lockWhenCondition:当线程A进入这里的时候，调用该方法，若不满足条件，线程就会进入休眠；若满足条件，就会得到锁并且执行下面的code。并且，若当前NSConditionLock的condition变为了满足的时候，线程A又会苏醒继续执行。当然，需要和unlockWithCondition结合使用。

下面就是一个实现多个并发任务同步执行的例子：

    NSConditionLock *clock = [[NSConditionLock alloc] initWithCondition:0];

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [clock lockWhenCondition:0];
        NSLog(@"任务1");
        [NSThread sleepForTimeInterval:1];
        [clock unlockWithCondition:2];
    });
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [clock lockWhenCondition:1];
        NSLog(@"任务2");
        [NSThread sleepForTimeInterval:1];
        [clock unlockWithCondition:3];
    });
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [clock lockWhenCondition:2];
        NSLog(@"任务3");
        [NSThread sleepForTimeInterval:1];
        [clock unlockWithCondition:1];
    });

打印如下：

任务1
任务3
任务2

解析：我们三个任务中都使用了lockWhenCondition方法（注意这里我用的是“任务”而非“线程”，“使用GCD线程的分配不是我们要关心的”），我们初始化锁的时候用condition=0，所以先走任务1，任务1执行完毕调用[clock unlockWithCondition:2];所以接着走任务3，同理最后走任务2。

注意：如果大量使用条件锁导致线程休眠，而开辟了过多的线程，将会对性能造成消耗，所以使用需谨慎。

3、NSRecursiveLock

我们修改一下之前的例子，当线程1获取到“锁”过后，再次调用lock。

- (void)addNum {
    [lock lock];
    [lock lock];
    NSLog(@"得到锁");
    NSLog(@"执行开始 i=%d, 线程：%@", i, [NSThread currentThread]);
    I++;
    [NSThread sleepForTimeInterval:1];  //让线程阻塞一秒
    NSLog(@"执行结束 i=%d, 线程：%@", i, [NSThread currentThread]);
    [lock unlock];
}

运行结果就是造成了“死锁”。还有一种常见的“死锁”的情况是：A线程获取到a锁，B线程获取到了b锁，同一时刻，A线程想要获取b锁，B线程想要获取a锁，A、B线程就会同时进入休眠（这就尴尬了）。

为了解决以上代码重复获取锁造成死锁的情况，我们引入了递归锁NSRecursiveLock。修改代码如下：

//注意：recursiveLock是一个NSRecursiveLock类型的全局变量，recursiveLock = [NSRecursiveLock new]

- (void)addNum {
    [recursiveLock lock];
    [recursiveLock lock];
    NSLog(@"得到锁");
    NSLog(@"执行开始 i=%d, 线程：%@", i, [NSThread currentThread]);
    I++;
    [NSThread sleepForTimeInterval:1];  //让线程阻塞一秒
    NSLog(@"执行结束 i=%d, 线程：%@", i, [NSThread currentThread]);
    [recursiveLock unlock];
    [recursiveLock unlock];
}

完美运行

注意一：使用NSRecursiveLock的时候，同样得注意获取锁和解锁需要一一对应，即一个lock对应一个unlock，不然锁不会处于可获取状态（哈哈，严谨吧，这里是不可获取状态而不是释放状态）。
注意二：若你能确定排除被重复加锁的情况，使用NSLock性能会更好。

4、@synchronized

@synchronized使用方法很简单，修改代码如下：

• (void)addNum {
  @synchronized(self){
  NSLog(@"得到锁");
  NSLog(@"执行开始 i=%d, 线程：%@", i, [NSThread currentThread]);
  I++;
  [NSThread sleepForTimeInterval:1]; //让线程阻塞一秒
  NSLog(@"执行结束 i=%d, 线程：%@", i, [NSThread currentThread]);
  }
  }

@synchronized(obj)，obj参数一般指定为互斥锁要保护的对象。值得提出的是，如果同一个obj对象做为了不同@synchronized(){}的参数，则这些代码块不能同时执行。

使用@synchronized我们不用管何时获取锁、何时释放锁，更容易的实现互斥，代码更加直观清晰；但是在性能上略显不足，而且实现并行算法有些复杂，不过这些都不能影响它极高的使用率。

下面盗一张ibireme的图，来看看各种锁的性能（图中的dispatch和pthread的锁有兴趣可以了解下。图的来源：https://blog.ibireme.com

image

写在后面

“锁”从来都不是为了炫技而生，大量使用锁不仅会带来性能问题，还会让代码更加的晦涩难懂，请大家合理的使用锁?。