浅谈iOS中的锁的介绍及使用

在平时的开发中经常使用到多线程，在使用多线程的过程中，难免会遇到资源竞争的问题，那我们怎么来避免出现这种问题那？

线程安全是什么？

当一个线程访问数据的时候，其他的线程不能对其进行访问，直到该线程访问完毕。简单来讲就是在同一时刻，对同一个数据操作的线程只有一个。只有确保了这样，才能使数据不会被其他线程影响。而线程不安全，则是在同一时刻可以有多个线程对该数据进行访问，从而得不到预期的结果。

比如写文件和读文件，当一个线程在写文件的时候，理论上来说，如果这个时候另一个线程来直接读取的话，那么得到的结果可能是你无法预料的。

怎么来保证线程安全？

通常我们使用锁的机制来保证线程安全，即确保同一时刻只有同一个线程来对同一个数据源进行访问。

yy大神 的 不再安全的 osspinlock 这边博客中列出了各种锁以及性能比较:

性能对比

这里性能比较的只是加锁立马解锁的时间消耗，并没有计算竞争时候的时间消耗。

锁的介绍及简单使用

1.@synchronized

@synchronized是 ios 中最常见的锁，用法很简单：

- (void)viewdidload {
  [super viewdidload];

  [self synchronized];
}

- (void)synchronized {
  nsobject * cjobj = [nsobject new];
  
  dispatch_async(dispatch_get_global_queue(dispatch_queue_priority_default, 0), ^{
    @synchronized(cjobj){
      nslog(@"线程1开始");
      sleep(3);
      nslog(@"线程1结束");
    }
  });
  
  dispatch_async(dispatch_get_global_queue(dispatch_queue_priority_default, 0), ^{
    sleep(1);
    @synchronized(cjobj){
      nslog(@"线程2");
    }
  });
}

控制台输出：

2017-10-18 11:35:13.459194+0800 thread-lock[24855:431100] 线程1开始
2017-10-18 11:35:16.460210+0800 thread-lock[24855:431100] 线程1结束
2017-10-18 11:35:16.460434+0800 thread-lock[24855:431101] 线程2

从上面的控制台输出时间可以看出来，在线程 1 内容全部输出之后，才输出了线程 2 的内容，“线程1结束”与“线程2”都是在“线程1开始”3 秒后输出的。

@synchronized(cjobj) 指令使用的 cjobj 为该锁的唯一标识，只有当标识相同时，才为满足互斥，如果线程 2 中的 @synchronized(cjobj) 改为 @synchronized(self) ，那么线程 2 就不会被阻塞，@synchronized 指令实现锁的优点就是我们不需要在代码中显式的创建锁对象，便可以实现锁的机制，但作为一种预防措施，@synchronized 块会隐式的添加一个异常处理例程来保护代码，该处理例程会在异常抛出的时候自动的释放互斥锁。所以如果不想让隐式的异常处理例程带来额外的开销，你可以考虑使用锁对象。

@sychronized(cjobj){} 内部 cjobj 被释放或被设为 nil 不会影响锁的功能，但如果 cjobj 一开始就是 nil，那就会丢失了锁的功能了。

2.nslock

先看看ios中nslock类的.h文件，从代码中可以看出，该类分成了几个子类：nslock、nsconditionlock、nsrecursivelock、nscondition，然后有一个 nslocking 协议：

@protocol nslocking
- (void)lock;
- (void)unlock;
@end

虽然 nslock、nsconditionlock、nsrecursivelock、nscondition 都遵循的了 nslocking 协议，但是它们并不相同。

2.1 nslock

nslock 实现了最基本的互斥锁，遵循了 nslocking 协议，通过 lock 和 unlock 来进行锁定和解锁。

源码内容：

@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

用法：

- (void)viewdidload {
  [super viewdidload];

  [self nslock];
}

- (void)nslock {
  nslock * cjlock = [nslock new];
  
  dispatch_async(dispatch_get_global_queue(dispatch_queue_priority_default, 0), ^{
    [cjlock lock];
    nslog(@"线程1加锁成功");
    sleep(2);
    [cjlock unlock];
    nslog(@"线程1解锁成功");
  });
  
  dispatch_async(dispatch_get_global_queue(dispatch_queue_priority_default, 0), ^{
    sleep(1);
    [cjlock lock];
    nslog(@"线程2加锁成功");
    [cjlock unlock];
    nslog(@"线程2解锁成功");
  });
}

控制台输出：

2017-10-19 15:03:58.868708+0800 thread-lock[39059:846493] 线程1加锁成功
2017-10-19 15:04:00.872714+0800 thread-lock[39059:846493] 线程1解锁成功
2017-10-19 15:04:00.872722+0800 thread-lock[39059:846492] 线程2加锁成功
2017-10-19 15:04:00.873000+0800 thread-lock[39059:846492] 线程2解锁成功

- (void)nslock {
  nslock * cjlock = [nslock new];
  
  dispatch_async(dispatch_get_global_queue(dispatch_queue_priority_default, 0), ^{
    [cjlock lock];
    nslog(@"线程1加锁成功");
    sleep(2);
    [cjlock unlock];
    nslog(@"线程1解锁成功");
  });
  
  dispatch_async(dispatch_get_global_queue(dispatch_queue_priority_default, 0), ^{
    if ([cjlock trylock]) {
      nslog(@"线程3加锁成功");
      [cjlock unlock];
      nslog(@"线程3解锁成功");
    }else {
      nslog(@"线程3加锁失败");
    }
  });
}

控制台输出：

2017-10-19 15:05:38.627767+0800 thread-lock[39118:849171] 线程1加锁成功
2017-10-19 15:05:38.627767+0800 thread-lock[39118:849169] 线程3加锁失败
2017-10-19 15:05:40.629969+0800 thread-lock[39118:849171] 线程1解锁成功

- (void)nslock {
  nslock * cjlock = [nslock new];
  
  dispatch_async(dispatch_get_global_queue(dispatch_queue_priority_default, 0), ^{
    [cjlock lock];
    nslog(@"线程1加锁成功");
    sleep(2);
    [cjlock unlock];
    nslog(@"线程1解锁成功");
  });
  dispatch_async(dispatch_get_global_queue(dispatch_queue_priority_default, 0), ^{
    sleep(3);
    if ([cjlock trylock]) {
      nslog(@"线程4加锁成功");
      [cjlock unlock];
      nslog(@"线程4解锁成功");
    }else {
      nslog(@"线程4加锁失败");
    }
  });
}

控制台输出：

2017-10-19 15:07:14.872279+0800 thread-lock[39166:851060] 线程1加锁成功
2017-10-19 15:07:16.876108+0800 thread-lock[39166:851060] 线程1解锁成功
2017-10-19 15:07:17.876208+0800 thread-lock[39166:851052] 线程4加锁成功
2017-10-19 15:07:17.876527+0800 thread-lock[39166:851052] 线程4解锁成功

- (void)nslock {
  nslock * cjlock = [nslock new];
  
  dispatch_async(dispatch_get_global_queue(dispatch_queue_priority_default, 0), ^{
    [cjlock lock];
    nslog(@"线程1加锁成功");
    sleep(2);
    [cjlock unlock];
    nslog(@"线程1解锁成功");
  });
  dispatch_async(dispatch_get_global_queue(dispatch_queue_priority_default, 0), ^{
    if ([cjlock lockbeforedate:[nsdate datewithtimeintervalsincenow:10]]) {
      nslog(@"线程5加锁成功");
      [cjlock unlock];
      nslog(@"线程5解锁成功");
    }else {
      nslog(@"线程5加锁失败");
    }
  });
}

控制台输出：

2017-10-19 15:08:39.705131+0800 thread-lock[39204:852782] 线程1加锁成功
2017-10-19 15:08:41.708717+0800 thread-lock[39204:852782] 线程1解锁成功
2017-10-19 15:08:41.708717+0800 thread-lock[39204:852784] 线程5加锁成功
2017-10-19 15:08:41.708935+0800 thread-lock[39204:852784] 线程5解锁成功
注意：lock与unlock操作必须在同一线程，否则结果不确定甚至会引起死锁

由以上内容总结：

1. 除 lock 和 unlock 方法外，nslock 还提供了 trylock 和 lockbeforedate:两个方法。
2. 由上面的结果可以看到 trylock 并不会阻塞线程，[cjlock trylock] 能加锁返回 yes，不能加锁返回 no，然后都会执行后续代码。
3. 这里顺便提一下 trylock 和 lock 使用场景：当前线程锁失败，也可以继续其它任务，用 trylock 合适；当前线程只有锁成功后，才会做一些有意义的工作，那就 lock，没必要轮询 trylock。以下的锁都是这样。
4. lockbeforedate: 方法会在所指定 date 之前尝试加锁，会阻塞线程，如果在指定时间之前都不能加锁，则返回 no，指定时间之前能加锁，则返回 yes。
5. 由于是互斥锁，当一个线程进行访问的时候，该线程获得锁，其他线程进行访问的时候，将被操作系统挂起，直到该线程释放锁，其他线程才能对其进行访问，从而却确保了线程安全。但是如果连续锁定两次，则会造成死锁问题。

2.2 nsrecursivelock

nsrecursivelock 是递归锁，顾名思义，可以被一个线程多次获得，而不会引起死锁。它记录了成功获得锁的次数，每一次成功的获得锁，必须有一个配套的释放锁和其对应，这样才不会引起死锁。nsrecursivelock 会记录上锁和解锁的次数，当二者平衡的时候，才会释放锁，其它线程才可以上锁成功。

源码内容：

@interface nsrecursivelock : 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

用法：

- (void)viewdidload {
  [super viewdidload];

  [self nsrecursivelock];
}

- (void)nsrecursivelock{
  nsrecursivelock * cjlock = [[nsrecursivelock alloc] init];
  
  dispatch_async(dispatch_get_global_queue(dispatch_queue_priority_default, 0), ^{
    static void (^recursiveblock)(int);
    recursiveblock = ^(int value) {
      [cjlock lock];
      nslog(@"%d加锁成功",value);
      if (value > 0) {
        nslog(@"value:%d", value);
        recursiveblock(value - 1);
      }
      [cjlock unlock];
      nslog(@"%d解锁成功",value);
    };
    recursiveblock(3);
  });
}

控制台输出：

2017-10-19 16:15:40.584213+0800 thread-lock[39579:894111] 3加锁成功
2017-10-19 16:15:40.584387+0800 thread-lock[39579:894111] value:3
2017-10-19 16:15:40.584552+0800 thread-lock[39579:894111] 2加锁成功
2017-10-19 16:15:40.584635+0800 thread-lock[39579:894111] value:2
2017-10-19 16:15:40.584810+0800 thread-lock[39579:894111] 1加锁成功
2017-10-19 16:15:40.585267+0800 thread-lock[39579:894111] value:1
2017-10-19 16:15:40.585714+0800 thread-lock[39579:894111] 0加锁成功
2017-10-19 16:15:40.585906+0800 thread-lock[39579:894111] 0解锁成功
2017-10-19 16:15:40.586138+0800 thread-lock[39579:894111] 1解锁成功
2017-10-19 16:15:40.586217+0800 thread-lock[39579:894111] 2解锁成功
2017-10-19 16:15:40.586314+0800 thread-lock[39579:894111] 3解锁成功

由以上内容总结：

如果用 nslock 的话，cjlock 先锁上了，但未执行解锁的时候，就会进入递归的下一层，而再次请求上锁，阻塞了该线程，线程被阻塞了，自然后面的解锁代码不会执行，而形成了死锁。而 nsrecursivelock 递归锁就是为了解决这个问题。

2.3 nsconditionlock

nsconditionlock 对象所定义的互斥锁可以在使得在某个条件下进行锁定和解锁，它和 nslock 类似，都遵循 nslocking 协议，方法都类似，只是多了一个 condition 属性，以及每个操作都多了一个关于 condition 属性的方法，例如 trylock、trylockwhencondition:，所以 nsconditionlock 可以称为条件锁。

1. 只有 condition 参数与初始化时候的 condition 相等，lock 才能正确进行加锁操作。
2. unlockwithcondition: 并不是当 condition 符合条件时才解锁，而是解锁之后，修改 condition 的值。

源码内容：

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

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

@end

用法：

- (void)viewdidload {
  [super viewdidload];

  [self nsconditionlock];
}

- (void)nsconditionlock {
  nsconditionlock * cjlock = [[nsconditionlock alloc] initwithcondition:0];
  
  dispatch_async(dispatch_get_global_queue(dispatch_queue_priority_default, 0), ^{
    [cjlock lock];
    nslog(@"线程1加锁成功");
    sleep(1);
    [cjlock unlock];
    nslog(@"线程1解锁成功");
  });
  
  dispatch_async(dispatch_get_global_queue(dispatch_queue_priority_default, 0), ^{
    sleep(1);
    [cjlock lockwhencondition:1];
    nslog(@"线程2加锁成功");
    [cjlock unlock];
    nslog(@"线程2解锁成功");
  });
  
  dispatch_async(dispatch_get_global_queue(dispatch_queue_priority_default, 0), ^{
    sleep(2);
    if ([cjlock trylockwhencondition:0]) {
      nslog(@"线程3加锁成功");
      sleep(2);
      [cjlock unlockwithcondition:2];
      nslog(@"线程3解锁成功");
    } else {
      nslog(@"线程3尝试加锁失败");
    }
  });
  
  dispatch_async(dispatch_get_global_queue(dispatch_queue_priority_default, 0), ^{
    if ([cjlock lockwhencondition:2 beforedate:[nsdate datewithtimeintervalsincenow:10]]) {
      nslog(@"线程4加锁成功");
      [cjlock unlockwithcondition:1];
      nslog(@"线程4解锁成功");
    } else {
      nslog(@"线程4尝试加锁失败");
    }
  });
}

控制台输出：

2017-10-19 15:09:44.010992+0800 thread-lock[39230:853946] 线程1加锁成功
2017-10-19 15:09:45.012045+0800 thread-lock[39230:853946] 线程1解锁成功
2017-10-19 15:09:46.012692+0800 thread-lock[39230:853947] 线程3加锁成功
2017-10-19 15:09:48.016536+0800 thread-lock[39230:853947] 线程3解锁成功
2017-10-19 15:09:48.016564+0800 thread-lock[39230:853944] 线程4加锁成功
2017-10-19 15:09:48.017039+0800 thread-lock[39230:853944] 线程4解锁成功
2017-10-19 15:09:48.017040+0800 thread-lock[39230:853945] 线程2加锁成功
2017-10-19 15:09:48.017215+0800 thread-lock[39230:853945] 线程2解锁成功

由以上内容总结：

1. 在线程 1 解锁成功之后，线程 2 并没有加锁成功，而是继续等了 1 秒之后线程 3 加锁成功，这是因为线程 2 的加锁条件不满足，初始化时候的 condition 参数为 0，而线程 2
2. 加锁条件是 condition 为 1，所以线程 2 加锁失败。
3. lockwhencondition 与 lock 方法类似，加锁失败会阻塞线程，所以线程 2 会被阻塞着。
4. trylockwhencondition: 方法就算条件不满足，也会返回 no，不会阻塞当前线程。
5. lockwhencondition:beforedate:方法会在约定的时间内一直等待 condition 变为 2，并阻塞当前线程，直到超时后返回 no。
6. 锁定和解锁的调用可以随意组合，也就是说 lock、lockwhencondition:与unlock、unlockwithcondition: 是可以按照自己的需求随意组合的。

2.4、nscondition

nscondition 是一种特殊类型的锁，通过它可以实现不同线程的调度。一个线程被某一个条件所阻塞，直到另一个线程满足该条件从而发送信号给该线程使得该线程可以正确的执行。比如说，你可以开启一个线程下载图片，一个线程处理图片。这样的话，需要处理图片的线程由于没有图片会阻塞，当下载线程下载完成之后，则满足了需要处理图片的线程的需求，这样可以给定一个信号，让处理图片的线程恢复运行。

1. nscondition 的对象实际上作为一个锁和一个线程检查器，锁上之后其它线程也能上锁，而之后可以根据条件决定是否继续运行线程，即线程是否要进入 waiting 状态，如果进入 waiting 状态，当其它线程中的该锁执行 signal 或者 broadcast 方法时，线程被唤醒，继续运行之后的方法。
2. nscondition 可以手动控制线程的挂起与唤醒，可以利用这个特性设置依赖。

源码内容：

@interface nscondition : nsobject <nslocking> {
@private
  void *_priv;
}

- (void)wait; //挂起线程
- (bool)waituntildate:(nsdate *)limit; //什么时候挂起线程
- (void)signal; // 唤醒一条挂起线程
- (void)broadcast; //唤醒所有挂起线程

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

@end

用法：

- (void)viewdidload {
  [super viewdidload];

  [self nscondition];
}

- (void)nscondition {
  nscondition * cjcondition = [nscondition new];
  
  dispatch_async(dispatch_get_global_queue(0, 0), ^{
    [cjcondition lock];
    nslog(@"线程1线程加锁");
    [cjcondition wait];
    nslog(@"线程1线程唤醒");
    [cjcondition unlock];
    nslog(@"线程1线程解锁");
  });
  
  dispatch_async(dispatch_get_global_queue(0, 0), ^{
    [cjcondition lock];
    nslog(@"线程2线程加锁");
    if ([cjcondition waituntildate:[nsdate datewithtimeintervalsincenow:10]]) {
      nslog(@"线程2线程唤醒");
      [cjcondition unlock];
      nslog(@"线程2线程解锁");
    }
  });
  
  dispatch_async(dispatch_get_global_queue(0, 0), ^{
    sleep(2);
    [cjcondition signal];
  });
}

控制台输出：

2017-10-19 17:15:48.410316+0800 thread-lock[40011:943638] 线程1线程加锁
2017-10-19 17:15:48.410757+0800 thread-lock[40011:943640] 线程2线程加锁
2017-10-19 17:15:50.414288+0800 thread-lock[40011:943638] 线程1线程唤醒
2017-10-19 17:15:50.414454+0800 thread-lock[40011:943638] 线程1线程解锁

//如果 [cjcondition signal]; 改成 [cjcondition broadcast];
  dispatch_async(dispatch_get_global_queue(0, 0), ^{
    sleep(2);
    [cjcondition broadcast];
  });

控制台输出：

2017-10-19 17:18:08.054109+0800 thread-lock[40056:946099] 线程1线程加锁
2017-10-19 17:18:08.054304+0800 thread-lock[40056:946096] 线程2线程加锁
2017-10-19 17:18:10.056071+0800 thread-lock[40056:946099] 线程1线程唤醒
2017-10-19 17:18:10.056231+0800 thread-lock[40056:946099] 线程1线程解锁
2017-10-19 17:18:10.056244+0800 thread-lock[40056:946096] 线程2线程唤醒
2017-10-19 17:18:10.056445+0800 thread-lock[40056:946096] 线程2线程解锁

由以上内容总结：

1. 在加上锁之后，调用条件对象的 wait 或 waituntildate: 方法来阻塞线程，直到条件对象发出唤醒信号或者超时之后，再进行之后的操作。
2. signal 和 broadcast 方法的区别在于，signal 只是一个信号量，只能唤醒一个等待的线程，想唤醒多个就得多次调用，而 broadcast 可以唤醒所有在等待的线程。

3.dispatch_semaphore

dispatch_semaphore 使用信号量机制实现锁，等待信号和发送信号。

1. dispatch_semaphore 是 gcd 用来同步的一种方式，与他相关的只有三个函数，一个是创建信号量，一个是等待信号，一个是发送信号。
2. dispatch_semaphore 的机制就是当有多个线程进行访问的时候，只要有一个获得了信号，其他线程的就必须等待该信号释放。

常用相关api：

dispatch_semaphore_create(long value);
dispatch_semaphore_wait(dispatch_semaphore_t _nonnull dsema, dispatch_time_t timeout);
dispatch_semaphore_signal(dispatch_semaphore_t _nonnull dsema);

用法：

- (void)viewdidload {
  [super viewdidload];

  [self dispatch_semaphore];
}

- (void)dispatch_semaphore {
  dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
  dispatch_time_t overtime = dispatch_time(dispatch_time_now, 6 * nsec_per_sec);

  dispatch_async(dispatch_get_global_queue(dispatch_queue_priority_default, 0), ^{
    dispatch_semaphore_wait(semaphore, overtime);
    nslog(@"线程1开始");
    sleep(5);
    nslog(@"线程1结束");
    dispatch_semaphore_signal(semaphore);
  });
  dispatch_async(dispatch_get_global_queue(dispatch_queue_priority_default, 0), ^{
    sleep(1);
    dispatch_semaphore_wait(semaphore, overtime);
    nslog(@"线程2开始");
    dispatch_semaphore_signal(semaphore);
  });
}

控制台输出：

2017-10-19 18:30:37.672490+0800 thread-lock[40569:993613] 线程1开始
2017-10-19 18:30:42.673845+0800 thread-lock[40569:993613] 线程1结束
2017-10-19 18:30:42.674165+0800 thread-lock[40569:993612] 线程2开始

//如果 overtime 改成 3 秒

控制台输出：
2017-10-19 18:32:32.078186+0800 thread-lock[40634:995921] 线程1开始
2017-10-19 18:32:35.082943+0800 thread-lock[40634:995920] 线程2开始
2017-10-19 18:32:37.083115+0800 thread-lock[40634:995921] 线程1结束

由以上内容总结：

1. dispatch_semaphore 和 nscondition 类似，都是一种基于信号的同步方式，但 nscondition 信号只能发送，不能保存（如果没有线程在等待，则发送的信号会失效）。而 dispatch_semaphore 能保存发送的信号。dispatch_semaphore 的核心是 dispatch_semaphore_t 类型的信号量。
2. dispatch_semaphore_create(1) 方法可以创建一个 dispatch_semaphore_t 类型的信号量，设定信号量的初始值为 1。注意，这里的传入的参数必须大于或等于 0，否则 dispatch_semaphore_create 会返回 null。
3. dispatch_semaphore_wait(semaphore, overtime); 方法会判断 semaphore 的信号值是否大于 0。大于 0 不会阻塞线程，消耗掉一个信号，执行后续任务。如果信号值为 0，该线程会和 nscondition 一样直接进入 waiting 状态，等待其他线程发送信号唤醒线程去执行后续任务，或者当 overtime 时限到了，也会执行后续任务。
4. dispatch_semaphore_signal(semaphore); 发送信号，如果没有等待的线程接受信号，则使 signal 信号值加一（做到对信号的保存）。
5. 一个 dispatch_semaphore_wait(semaphore, overtime); 方法会去对应一个 dispatch_semaphore_signal(semaphore); 看起来像 nslock 的 lock 和 unlock，其实可以这样理解，区别只在于有信号量这个参数，lock unlock 只能同一时间，一个线程访问被保护的临界区，而如果 dispatch_semaphore 的信号量初始值为 x ，则可以有 x 个线程同时访问被保护的临界区。

4.pthread_mutex 与 pthread_mutex(recursive)

pthread 表示 posix thread，定义了一组跨平台的线程相关的 api，posix 互斥锁是一种超级易用的互斥锁，使用的时候：

1. 只需要使用 pthread_mutex_init 初始化一个 pthread_mutex_t，
2. pthread_mutex_lock 或者 pthread_mutex_trylock 来锁定 ，
3. pthread_mutex_unlock 来解锁，
4. 当使用完成后，记得调用 pthread_mutex_destroy 来销毁锁。

常用相关api：

pthread_mutex_init(pthread_mutex_t *restrict _nonnull, const pthread_mutexattr_t *restrict _nullable);
pthread_mutex_lock(pthread_mutex_t * _nonnull);
pthread_mutex_trylock(pthread_mutex_t * _nonnull);
pthread_mutex_unlock(pthread_mutex_t * _nonnull);
pthread_mutex_destroy(pthread_mutex_t * _nonnull);

用法：

//pthread_mutex

- (void)viewdidload {
  [super viewdidload];

  [self pthread_mutex];
}

- (void)pthread_mutex {
  __block pthread_mutex_t cjlock;
  pthread_mutex_init(&cjlock, null);
  
  dispatch_async(dispatch_get_global_queue(dispatch_queue_priority_default, 0), ^{
    pthread_mutex_lock(&cjlock);
    nslog(@"线程1开始");
    sleep(3);
    nslog(@"线程1结束");
    pthread_mutex_unlock(&cjlock);
    
  });
  
  dispatch_async(dispatch_get_global_queue(dispatch_queue_priority_default, 0), ^{
    sleep(1);
    pthread_mutex_lock(&cjlock);
    nslog(@"线程2");
    pthread_mutex_unlock(&cjlock);
  });
}

控制台输出：

2017-10-23 14:50:29.842180+0800 thread-lock[74478:1647362] 线程1开始
2017-10-23 14:50:32.846786+0800 thread-lock[74478:1647362] 线程1结束
2017-10-23 14:50:32.847001+0800 thread-lock[74478:1647359] 线程2

//pthread_mutex(recursive)

- (void)viewdidload {
  [super viewdidload];

  [self pthread_mutex_recursive];
}

- (void)pthread_mutex_recursive {
  __block pthread_mutex_t cjlock;
  
  pthread_mutexattr_t attr;
  pthread_mutexattr_init(&attr);
  pthread_mutexattr_settype(&attr, pthread_mutex_recursive);
  pthread_mutex_init(&cjlock, &attr);
  pthread_mutexattr_destroy(&attr);
  
  dispatch_async(dispatch_get_global_queue(dispatch_queue_priority_default, 0), ^{
    
    static void (^recursiveblock)(int);
    
    recursiveblock = ^(int value) {
      pthread_mutex_lock(&cjlock);
      nslog(@"%d加锁成功",value);
      if (value > 0) {
        nslog(@"value = %d", value);
        sleep(1);
        recursiveblock(value - 1);
      }
      nslog(@"%d解锁成功",value);
      pthread_mutex_unlock(&cjlock);
    };
    recursiveblock(3);
  });
}

//控制台输出：
2017-10-23 15:31:51.599693+0800 thread-lock[74723:1668089] 3加锁成功
2017-10-23 15:31:51.599912+0800 thread-lock[74723:1668089] value = 3
2017-10-23 15:31:52.602002+0800 thread-lock[74723:1668089] 2加锁成功
2017-10-23 15:31:52.602317+0800 thread-lock[74723:1668089] value = 2
2017-10-23 15:31:53.604669+0800 thread-lock[74723:1668089] 1加锁成功
2017-10-23 15:31:53.604957+0800 thread-lock[74723:1668089] value = 1
2017-10-23 15:31:54.607778+0800 thread-lock[74723:1668089] 0加锁成功
2017-10-23 15:31:54.608109+0800 thread-lock[74723:1668089] 0解锁成功
2017-10-23 15:31:54.608391+0800 thread-lock[74723:1668089] 1解锁成功
2017-10-23 15:31:54.608622+0800 thread-lock[74723:1668089] 2解锁成功
2017-10-23 15:31:54.608945+0800 thread-lock[74723:1668089] 3解锁成功

由以上内容总结：

1. 它的用法和 nslock 的 lock unlock 用法一致，而它也有一个 pthread_mutex_trylock 方法，pthread_mutex_trylock 和 trylock 的区别在于，trylock 返回的是 yes 和 no，pthread_mutex_trylock 加锁成功返回的是 0，失败返回的是错误提示码。
2. pthread_mutex(recursive) 作用和 nsrecursivelock 递归锁类似。如果使用 pthread_mutex_init(&thelock, null); 初始化锁的话，上面的代码的第二部分会出现死锁现象，使用递归锁就可以避免这种现象。

5. osspinlock

osspinlock 是一种自旋锁，和互斥锁类似，都是为了保证线程安全的锁。但二者的区别是不一样的，对于互斥锁，当一个线程获得这个锁之后，其他想要获得此锁的线程将会被阻塞，直到该锁被释放。但自选锁不一样，当一个线程获得锁之后，其他线程将会一直循环在哪里查看是否该锁被释放。所以，此锁比较适用于锁的持有者保存时间较短的情况下。

只有加锁，解锁，尝试加锁三个方法。

常用相关api：

typedef int32_t osspinlock;

// 加锁
void  osspinlocklock( volatile osspinlock *__lock );
// 尝试加锁
bool  osspinlocktry( volatile osspinlock *__lock );
// 解锁
void  osspinlockunlock( volatile osspinlock *__lock );

用法：

#import <libkern/osatomic.h>

- (void)viewdidload {
  [super viewdidload];

  [self osspinlock];
}

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

控制台输出：

2017-10-23 16:02:48.865501+0800 thread-lock[75025:1684487] 线程1开始
2017-10-23 16:02:51.868736+0800 thread-lock[75025:1684487] 线程1结束
2017-10-23 16:02:52.922911+0800 thread-lock[75025:1684486] 线程2
yy大神 @ibireme 的文章也有说这个自旋锁存在优先级反转问题，具体文章可以戳 不再安全的 osspinlock，而 osspinlock 在ios 10.0中被 <os/lock.h> 中的 os_unfair_lock 取代。

6.os_unfair_lock

自旋锁已经不再安全，然后苹果又整出来个 os_unfair_lock，这个锁解决了优先级反转问题。

常用相关api：

// 初始化
os_unfair_lock_t unfairlock = &(os_unfair_lock_init);
// 加锁
os_unfair_lock_lock(unfairlock);
// 尝试加锁
bool b = os_unfair_lock_trylock(unfairlock);
// 解锁
os_unfair_lock_unlock(unfairlock);
os_unfair_lock 用法和 osspinlock 基本一直，就不一一列出了。

总结

应当针对不同的操作使用不同的锁，而不能一概而论哪种锁的加锁解锁速度快。

1. 其实每一种锁基本上都是加锁、等待、解锁的步骤，理解了这三个步骤就可以帮你快速的学会各种锁的用法。
2. @synchronized 的效率最低，不过它的确用起来最方便，所以如果没什么性能瓶颈的话，可以选择使用 @synchronized。
3. 当性能要求较高时候，可以使用 pthread_mutex 或者 dispath_semaphore，由于 osspinlock 不能很好的保证线程安全，而在只有在 ios10 中才有 os_unfair_lock ，所以，前两个是比较好的选择。既可以保证速度，又可以保证线程安全。
4. 对于 nslock 及其子类，速度来说 nslock < nscondition < nsrecursivelock < nsconditionlock 。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。