锁的种类及其特点

在Objective-C中，如果有多个线程要执行同一份代码，就会出现线程安全问题。锁机制正是用于解决这一问题，确保同一时间内只有一个线程执行目标代码。



@synchronized(anObject)

说明：根据给定的对象，自动创建一个锁，并等待块中的代码执行完毕。当执行到代码结尾处时，锁就释放了，如

  1. // 该类用于多线程环境下的测试
  3. @implementation TestObj
  5. - (void)method1 {
  6.     NSLog(@"Test: %@",NSStringFromSelector(_cmd));
  7. }
  9. - (void)method2 {
  10.     NSLog(@"Test: %@",NSStringFromSelector(_cmd));    
  11. }
  13. @end
  1. #import "TestObj.h"
  2. #import "ViewController.h"
  4. @implementation ViewController
  6. - (void)viewDidLoad {
  7.     [super viewDidLoad];
  9.     // 主线程中
  10.     TestObj *obj = [[TestObj alloc] init];
  12.     // 线程1
  13.     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  14.         @synchronized (self) {
  15.             [obj method1];
  16.             sleep(5);
  17.         }
  18.     });
  20.     // 线程2
  21.     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  22.         sleep(1); // 以保证让线程2的代码后执行
  23.         @synchronized (self) {
  24.             [obj method2];
  25.         }
  26.     });
  27. }
  29. @end
  31. 结果：method1 执行后，等待5秒再执行 method2，即线程1锁住后，线程2会一直等待，直到线程1解锁后，method2 才会执行。

优点：不需要在代码中显式的创建锁对象，便可以实现锁的机制

缺点：@synchronized(anObject)方法针对anObject只有一个锁（多个同步块会共用这个锁），如果有多个同步块，则其他的同步块都要等待当前同步块执行完毕才能继续执行，降低了执行效率，如



NSLock

说明：最基本的锁对象，如

  1. #import "TestObj.h"
  2. #import "ViewController.h"
  4. @implementation ViewController
  6. - (void)viewDidLoad {
  7.     [super viewDidLoad];
  9.     // 主线程中
  10.     TestObj *obj = [[TestObj alloc] init];
  11.     NSLock *lock = [[NSLock alloc] init];
  13.     // 线程1
  14.     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  15.         [lock lock];
  16.         [obj method1];
  17.         sleep(5);
  18.         [lock unlock];
  19.     });
  21.     // 线程2
  22.     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  23.         sleep(1); // 以保证让线程2的代码后执行
  24.         [lock lock];
  25.         [obj method2];
  26.         [lock unlock];
  27.     });
  28. }
  30. @end

缺点：使用不当容易出现死锁，比如在递归或循环中使用（这种情况下，适合用NSRecursiveLock）

  1. #import "ViewController1.h"
  2. #import "TestObj.h"
  5. @implementation ViewController1
  7. - (void)viewDidLoad {
  8.     [super viewDidLoad];
  10.     // 主线程中
  11.     NSLock *theLock = [[NSLock alloc] init];
  12.     TestObj *obj = [[TestObj alloc] init];
  14.     // 线程1
  15.     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  16.         static void(^TestMethod)(int);
  17.         TestMethod = ^(int value) {
  18.             [theLock lock];
  19.             if (value > 0) {
  20.                 [obj method1];
  21.                 sleep(5);
  22.                 TestMethod(value-1);
  23.             }
  24.             [theLock unlock];
  25.         };
  26.         TestMethod(5);
  27.     });
  29.     // 线程2
  30.     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  31.         sleep(1);
  32.         [theLock lock];
  33.         [obj method2];
  34.         [theLock unlock];
  35.     });
  36. }
  38. @end
  40. 结果：method1 只会被调用一次（预期是5次），method2 不会被调用。
  42. 原因：线程1被加锁2次（TestMethod内 [theLock lock] 被执行2次），却从未解锁（TestMethod内 [theLock unlock] 一次都没执行），出现了死锁，导致线程1与线程2都被锁住了。



C语言的pthread_mutex_t

  1. #import "pthread.h"
  2. #import "TestObj.h"
  3. #import "ViewController.h"
  5. @implementation ViewController
  7. - (void)viewDidLoad {
  8.     [super viewDidLoad];
  10.     // 主线程中
  11.     TestObj *obj = [[TestObj alloc] init];
  12.     __block pthread_mutex_t mutex;
  13.     pthread_mutex_init(&mutex, NULL);
  15.     // 线程1
  16.     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  17.         pthread_mutex_lock(&mutex);
  18.         [obj method1];
  19.         sleep(5);
  20.         pthread_mutex_unlock(&mutex);
  21.     });
  23.     // 线程2
  24.     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  25.         sleep(1);
  26.         pthread_mutex_lock(&mutex);
  27.         [obj method2];
  28.         pthread_mutex_unlock(&mutex);
  29.     });
  30. }
  32. @end



GCD信号量

  1. #import "TestObj.h"
  2. #import "ViewController.h"
  4. @implementation ViewController
  6. - (void)viewDidLoad {
  7.     [super viewDidLoad];
  9.     // 主线程中
  10.     TestObj *obj = [[TestObj alloc] init];
  11.     dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
  13.     // 线程1
  14.     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  15.         // 减少信号量
  16.         dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
  17.         [obj method1];
  18.         sleep(5);
  19.         // 增加信号量
  20.         dispatch_semaphore_signal(semaphore);
  21.     });
  23.     // 线程2
  24.     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  25.         sleep(1);
  26.         dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
  27.         [obj method2];
  28.         dispatch_semaphore_signal(semaphore);
  29.     });
  30. }
  32. @end



NSRecursiveLock

说明：递归锁，该类定义的锁可以在同一线程多次lock，而不会造成死锁。递归锁会跟踪它被lock多少次，每次成功的lock都必须平衡调用unlock操作，只有所有的加锁和解锁操作都平衡的时候，锁才真正被释放给其他线程获得。

NSLock章节的死锁例子，只需将锁换成递归锁即可解决，如

  1. #import "ViewController1.h"
  2. #import "TestObj.h"
  5. @implementation ViewController1
  7. - (void)viewDidLoad {
  8.     [super viewDidLoad];
  10.     // 主线程中
  11.     NSRecursiveLock *theLock = [[NSRecursiveLock alloc] init];
  12.     TestObj *obj = [[TestObj alloc] init];
  14.     // 线程1
  15.     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  16.         static void(^TestMethod)(int);
  17.         TestMethod = ^(int value) {
  18.             [theLock lock];
  19.             if (value > 0) {
  20.                 [obj method1];
  21.                 sleep(5);
  22.                 TestMethod(value-1);
  23.             }
  24.             [theLock unlock];
  25.         };
  26.         TestMethod(5);
  27.     });
  29.     // 线程2
  30.     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  31.         sleep(1);
  32.         [theLock lock];
  33.         [obj method2];
  34.         [theLock unlock];
  35.     });
  36. }
  38. @end
  40. 结果：线程1中 TestMethod 执行5次后，再执行线程2中的代码。



NSConditionLock

说明：条件锁，只有满足指定条件的情况下才能解锁或加锁，如

  1. #import "ViewController.h"
  3. @implementation ViewController1
  5. - (void)viewDidLoad {
  6.     [super viewDidLoad];
  8.     // 主线程中
  9.     NSConditionLock *theLock = [[NSConditionLock alloc] init];
  11.     // 线程1
  12.     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  13.         for (int i=0;i<=2;i++)
  14.         {
  15.             [theLock lock];
  16.             NSLog(@"thread1:%d",i);
  17.             sleep(1);
  18.             // 满足指定条件时才解锁
  19.             [theLock unlockWithCondition:i];
  20.         }
  21.     });
  23.     // 线程2
  24.     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  25.         // 满足指定条件才加锁
  26.         [theLock lockWhenCondition:2];
  27.         NSLog(@"thread2");
  28.         [theLock unlock];
  29.     });
  30. }
  32. @end
  34. 结果：thread1:0，thread1:1，thread1:2，thread2

注意：NSConditionLock也跟其它的锁一样：需要lock与unlock对应，只是lock、lockWhenCondition:与unlock、unlockWithCondition:是可以随意组合的。



NSDistributedLock

说明：分布锁，通过文件系统实现，适用于在多个进程或多个程序之间构建互斥的场景（其他的锁都用于解决多线程之间的冲突），它并非继承于NSLock，只实现了tryLock，unlock，breakLock，如（注：该示例没有亲自验证过）

  1. // 程序A
  2. dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  3.     NSDistributedLock *lock = [[NSDistributedLock alloc] initWithPath:@"file path"];
  4.     [lock breakLock];
  5.     [lock tryLock];
  6.     sleep(5);
  7.     [lock unlock];
  8.     NSLog(@"appA: OK");
  9. });
  11. // 程序B
  12. dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  13.     NSDistributedLock *lock = [[NSDistributedLock alloc] initWithPath:@"file path"];
  14.     while (![lock tryLock]) {
  15.         NSLog(@"appB: waiting");
  16.         sleep(1);
  17.     }
  18.     [lock unlock];
  19.     NSLog(@"appB: OK");
  20. });
  22. 结果：当程序A运行的时候，程序B一直处于等待中，大概5秒之后，程序B打印出log。

注意：程序A与程序B中的file path必须是同一个文件或文件夹的地址，如果该地址不存在，那么在tryLock返回YES时，会自动创建该文件或文件夹。在结束时该文件/文件夹会被清除，所以在选择的该路径的时候，应该选择一个不存在的路径，以防止误删了文件。