1. NSLock

NSLock实现了最基本的互斥锁，遵循了NSLocking协议，通过lock和unlock来进行锁定和解锁。其使用也非常简单，由于是互斥锁，当一个线程进行访问的时候，该线程获得锁，其他线程进行访问的时候，将被操作系统挂起，直到该线程释放锁，其他线程才能对其进行访问，从而确保了线程安全。但是如果连续锁定两次，则会造成死锁问题。

    _lock = [[NSLock alloc] init];
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"1");
        [self lockFounction:[NSThread currentThread] num: 1];
    });
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"2");
        [self lockFounction:[NSThread currentThread] num: 2];
    });
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"3");
        [self lockFounction:[NSThread currentThread] num: 3];
    });

    - (void)lockFounction:(NSThread *)thread num:(NSInteger) num {
        [_lock lock];
        NSLog(@"thread - %@, num - %ld", thread, num);
        sleep(5);
        [_lock unlock];
    }

以下为运行结果，正好每5秒执行一次。

image.png

- (void)lockFounction:(NSThread *)thread num:(NSInteger) num {
    [_lock tryLock];
    NSLog(@"thread - %@ num - %ld", thread, num);
    sleep(5);
    [_lock unlock];
}

比如把方法改成这样，然而输出结果却不是之前那样，如下图，这里根本就没有起到上锁的效果。在我的理解是，方法中只有在lock和unlock中间的临界区代码才能得到线程保护，但是你把lock改成tryLock以后，只有第一个进入该方法的线程，才会tryLock成功并等价的执行lock方法，但是对另外的线程根本就没有约束力，因为他们获取不到锁，什么都没有执行。导致临界区的方法直接被执行了，而不会被挂起。

image.png

这里我想说一下，在我的理解，NSLock的应用应该是多条线程执行同一个方法的时候为了确保线程安全而使用，而不是多条线程各自执行一个方法的时候使用。也就是类似下面的这个例子，我觉得是错误的使用方式。如果我理解的不对，大家可以指出来，我们一起探讨。

image.png

2. NSRecursiveLock

大家都叫它递归锁，它可以允许同一线程多次加锁，而不会造成死锁。递归锁会跟踪它被lock的次数。每次成功的lock都必须有对应的unlock操作。只有达到这种平衡，锁最后才能被释放，以供其它线程使用。下面直接上代码和执行效果。它的tryLock方法，和NSLock是相同的，都是尝试获取锁的意思，这里就不多做说明。

    _lock = [[NSRecursiveLock alloc] init];
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"1");
        [self lockFounction:[NSThread currentThread] num: 1 count:5];
    });
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"2");
        [self lockFounction:[NSThread currentThread] num: 2 count:6];
    });
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"3");
        [self lockFounction:[NSThread currentThread] num: 3 count:7];
    });

    - (void)lockFounction:(NSThread *)thread num:(NSInteger) num count:(NSInteger)count {
        [_lock lock];
        NSLog(@"thread - %@ num - %ld, count - %ld", thread, num, count);
        if (count != 0) {
            count --;
            sleep(2);
            [self lockFounction:thread num:num count:count];
        }
        [_lock unlock];
    }

image.png

3. NSCondition

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

    _ifFinished = NO;
    _lock = [[NSCondition alloc] init];
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        sleep(1);
        [self downLoad];
    });
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [self doSomeThing];
    });

- (void)downLoad {
    NSLog(@"downLoad begin %@", [NSThread currentThread]);
    [_lock lock];
    sleep(5);
    NSLog(@"downLoad finish");
    _ifFinished = YES;
    [_lock signal];    //发送信号
    [_lock unlock];
}

- (void)doSomeThing {
    [_lock lock];
    NSLog(@"doSomeThing begin %@", [NSThread currentThread]);
    while (!_ifFinished) {
        NSLog(@"wait");
        [_lock wait];        //等待信号
    }
    NSLog(@"doSomeThing end %@", [NSThread currentThread]);
    [_lock unlock];
}

image.png

• wait方法的本质是锁的转移，消费者放弃锁，然后生产者获得锁，同理，signal则是一个锁从生产者到消费者转移的过程。
• 这里一个signal信号，只能对应一个wait，如果存在多个wait，只会唤醒第一个。
• NSCondition的lock也有互斥效果，但是在执行wait方法放弃锁，线程进行等待的时候，锁的效果将会失效。
• 自然我们会有疑问:“如果不用互斥锁，只用条件变量（wait和signal）会有什么问题呢？”。downLoad方法睡眠的那5秒（即模拟获取数据的过程）; 这段代码不是线程安全的，也许在你把数据获取出来以前，已经有别的线程修改了数据。因此我们需要保证消费者拿到的数据是线程安全的。
• wait方法除了会被signal方法唤醒，有时还会被虚假唤醒，所以需要这里while循环中的判断来做二次确认。

4. NSConditionLock

NSConditionLock对象所定义的互斥锁可以在某个条件下进行锁定和解锁。它和 NSCondition 很像，但实现方式是不同的。

当两个线程需要特定顺序执行的时候，例如生产者消费者模型，则可以使用 NSConditionLock。当生产者执行任务的时候，可以通过特定的条件获得锁，当生产者完成执行的时候，它将解锁该锁，然后把锁的条件设置成唤醒消费者线程的条件。锁定和解锁的调用可以随意组合。

    //condition默认是0
    _lock = [[NSConditionLock alloc] initWithCondition:5];
    NSTimer * timer1 = [NSTimer timerWithTimeInterval:1 repeats:YES block:^(NSTimer * _Nonnull timer) {
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            [self producer];
        });
    }];
    NSTimer * timer2 = [NSTimer timerWithTimeInterval:3 repeats:YES block:^(NSTimer * _Nonnull timer) {
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            [self consumer];
        });
    }];
    [[NSRunLoop currentRunLoop] addTimer:timer1 forMode:NSRunLoopCommonModes];
    [[NSRunLoop currentRunLoop] addTimer:timer2 forMode:NSRunLoopCommonModes];

- (void)producer {
    /**
     这里如果直接使用 lockWhenCondition: 方法。
     跑几分钟后就会卡死，猜测是因为锁死。具体的原因我没有想明白，如果你想明白了麻烦告诉我。
     
     用tryLock方法，我跑了10几分钟依旧正常运行。
     并且注意，只有在tryLock成功的情况下才进行具体的操作。
     */
    if ([_lock tryLockWhenCondition:5]) {
        NSLog(@"have something %@", [NSThread currentThread]);
        _count ++;
        [_lock unlockWithCondition:6];
    }
}

- (void)consumer {
    if ([_lock tryLockWhenCondition:6]) {
        NSLog(@"use something %@", [NSThread currentThread]);
        _count --;
        NSLog(@"%ld", _count);
        [_lock unlockWithCondition:5];
    }
}

image.png

参考链接：
http://www.cocoachina.com/ios/20161129/18216.html
http://www.codeceo.com/article/ios-lock.html