35、iOS底层分析 - 线程锁（四）条件锁 NSconditionLock

条件锁 NSConditionLock

1、定义

条件锁就是有特定条件的锁，所谓条件只是一个抽象概念，由程序猿自定义。说白了就是「有条件的互斥锁」.对于NSConditionLock，官方文档的描述是这样的：

使用NSConditionLock对象，可以确保线程仅在满足特定条件时才能获取锁。一旦获得了锁并执行了代码的关键部分，线程就可以放弃该锁并将关联条件设置为新的条件。条件本身是任意的：您可以根据应用程序的需要定义它们。

NSConditionLock 同样实现了 NSLocking 协议，并定义了一些特定的接口：

@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

可以看到，所谓的条件condition就是个NSInteger，没有其他任何限制，使用起来就像UIView的tag一样。类的定义中，不带condition 的和 NSLock 没什么区别。特有的：

只读属性condition，保存锁当前的条件
-lockWhenCondition:：获取锁，如果condition与属性相等，则可以获得锁，否则阻塞线程，等待被唤醒
-unlockWithCondition:释放锁，并修改condition属性

2、条件锁汇编分析

-(void)ljl_testCondition2
{
//    类似于信号量
    NSConditionLock * conditionLock = [[NSConditionLock alloc] initWithCondition:2];
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
        [conditionLock lockWhenCondition:1];
        NSLog(@"线程1");
        [conditionLock unlockWithCondition:0];
    });
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0), ^{
        [conditionLock lockWhenCondition:2];
        NSLog(@"线程2");
        [conditionLock unlockWithCondition:1];
    });
    
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        [conditionLock lock];
        NSLog(@"线程3");
        [conditionLock unlock];
    });
}

//****************************************************
2020-04-06 21:45:38.273772+0800 filedome[1802:45978] 线程2
2020-04-06 21:45:38.274064+0800 filedome[1802:45870] 线程1
2020-04-06 21:45:38.274198+0800 filedome[1802:45871] 线程3

线程3 和线程2谁先执行不一定，但是线程1一定是在线程2之后执行的。

执行线程1、2、3（顺序不确定的）

但线程1 、2获取锁需要看 condition 是否满足

线程3 获取锁不需要条件，先获取到锁，开始执行任务（不一定是最先执行的）
线程2 因为条件是2，所以线程2可以执行。当线程2释放锁时将condition置为1，满足线程1的条件，此时线程1获取到锁执行任务
线程1 释放锁时将condition置为0，不再执行任务

在 [conditionLock lockWhenCondition:1]; 打断点。汇编查看

然后下符号断点 lockWhenCondition: + -> Symbolic BreakPoint... -> -[NSConditionLock lockWhenCondition:]
然后下符号断点 unlockWhenCondition: + -> Symbolic BreakPoint... -> -[NSConditionLock unlockWhenCondition:]

这个date 哪来的干什么的不知道看一下文档。 xcode中选中 lockWhenCondition -> Help -> Search Documentation for Selected Text

- (BOOL)lockWhenCondition:(NSInteger)condition beforeDate:(NSDate *)limit;
被锁的话此方法将阻塞线程的执行，直到解锁或超时为止。

通过调试，发现NSConditionLock 是对 NSCondition 的封装。通过加锁来解决线程完全问题，那么条件是怎么什么地方处理的呢?

扫描二维码关注公众号，回复： 11046794 查看本文章

最后发现有调用了 waitUntilDate：这个跟 [_testCondition wait]; 是一样的，条件不一样的时候进行等待。

执行完调用 broadcast 进行广播

即使在未来某个时间点可以满足条件，但-tryLockWhenCondition:只是根据当前condition获取锁

无论能否获取到锁，该线程都会继续向下执行，不会阻塞

3、应用

    //主线程中
    NSConditionLock *lock = [[NSConditionLock alloc] initWithCondition:0];

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

    //线程2
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        sleep(1);//以保证让线程2的代码后执行
        if ([lock tryLockWhenCondition:0]) {
            NSLog(@"线程2");
            [lock unlockWithCondition:2];
            NSLog(@"线程2解锁成功");
        } else {
            NSLog(@"线程2尝试加锁失败");
        }
    });

    //线程3
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        sleep(2);//以保证让线程2的代码后执行
        if ([lock tryLockWhenCondition:2]) {
            NSLog(@"线程3");
            [lock unlock];
            NSLog(@"线程3解锁成功");
        } else {
            NSLog(@"线程3尝试加锁失败");
        }
    });

    //线程4
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        sleep(3);//以保证让线程2的代码后执行
        if ([lock tryLockWhenCondition:2]) {
            NSLog(@"线程4");
            [lock unlockWithCondition:1];    
            NSLog(@"线程4解锁成功");
        } else {
            NSLog(@"线程4尝试加锁失败");
        }
    });

2016-08-19 13:51:15.353 ThreadLockControlDemo[1614:110697] 线程2
2016-08-19 13:51:15.354 ThreadLockControlDemo[1614:110697] 线程2解锁成功
2016-08-19 13:51:16.353 ThreadLockControlDemo[1614:110689] 线程3
2016-08-19 13:51:16.353 ThreadLockControlDemo[1614:110689] 线程3解锁成功
2016-08-19 13:51:17.354 ThreadLockControlDemo[1614:110884] 线程4
2016-08-19 13:51:17.355 ThreadLockControlDemo[1614:110884] 线程4解锁成功
2016-08-19 13:51:17.355 ThreadLockControlDemo[1614:110884] 线程1

上面代码先输出了 ”线程 2“，因为线程 1 的加锁条件不满足，初始化时候的 condition 参数为 0，而加锁条件是 condition 为 1，所以加锁失败。locakWhenCondition 与 lock 方法类似，加锁失败会阻塞线程，所以线程 1 会被阻塞着，而 tryLockWhenCondition 方法就算条件不满足，也会返回 NO，不会阻塞当前线程。

回到上面的代码，线程 2 执行了 [lock unlockWithCondition:2]; 所以 Condition 被修改成了 2。

而线程 3 的加锁条件是 Condition 为 2，所以线程 3 才能加锁成功，线程 3 执行了 [lock unlock]; 解锁成功且不改变 Condition 值。

线程 4 的条件也是 2，所以也加锁成功，解锁时将 Condition 改成 1。这个时候线程 1 终于可以加锁成功，解除了阻塞。

从上面可以得出，NSConditionLock 还可以实现任务之间的依赖。

4、注意事项

由于NSConditionLock也实现了NSLocking协议，可以通过-lock加锁以及-unlock解锁，但无论当前condition是多少，-lock都可以获得锁，-unlock也不会改变当前condition的值。
由于是同一把锁，同一时间只能由一个线程持有，如果当前condition满足线程1的持锁条件，但线程2通过-lock获取没有条件的锁，此时他们谁先抢到锁就执行谁的任务，另一个就要等锁释放。
通过-lockWhenCondition:获取锁时，线程会休眠等待，必须有其他线程设置为合适的条件，否则该线程永远获取不到锁

熟悉了条件锁NSConditionLock的使用方法，可以用一个任务编号（条件）来指定不同线程任务的执行顺序。

6.源码

先看NSConditionLock的属性：

open class NSConditionLock : NSObject, NSLocking {
    internal var _cond = NSCondition()
    internal var _value: Int
    internal var _thread: _swift_CFThreadRef?
}

_cond：一个NSCondition对象
_value：记录当前条件的值
_thread：记录当前线程

无论是-lock还是-lockWhenCondition:都会走这个函数：

open func lock(whenCondition condition: Int, before limit: Date) -> Bool {
        _cond.lock()
    while _thread != nil || _value != condition {
        if !_cond.wait(until: limit) {
            _cond.unlock()
            return false
        }
    }
    _thread = pthread_self()
    _cond.unlock()
    return true
}

如果当前条件和condition不相等，则再一次休眠等待，否则可以获得锁

释放条件锁：

open func unlock(withCondition condition: Int) {
    _cond.lock()
    _thread = nil
    _value = condition
    _cond.broadcast()
    _cond.unlock()
}

将当前条件更新，并broadcast()唤醒所有等待在这个锁的线程

shengdaVolleyball

发布了104 篇原创文章 · 获赞 13 · 访问量 19万+

私信关注