线程同步之条件锁

LockMind.png

这是并发控制方案的系列文章，介绍了各种锁的使用及优缺点。

1. 自旋锁
2. os_unfair_lock
3. 互斥锁
4. 递归锁
5. 条件锁
6. 读写锁
7. @synchronized

OSSpinLock、os_unfair_lock、pthread_mutex_t、pthread_cond_t、pthread_rwlock_t 是值类型，不是引用类型。这意味着使用 = 会进行复制，使用复制的可能导致闪退。pthread 函数认为其一直处于初始化的内存地址，将其移动到其他内存地址会产生问题。使用copy的OSSpinLock不会崩溃，但会得到一个全新的锁。

如果你对线程、进程、串行、并发、并行、锁等概念还不了解，建议先查看以下文章：

• Grand Central Dispatch的使用
• Operation、OperationQueue的使用
• 多线程简述
• 并发控制之线程同步
• 并发控制之无锁编程

条件变量（Condition Variable）是一种同步工具，允许线程暂停执行、进入休眠，直到某些共享资源满足条件。条件变量基本操作如下：

• 向条件发出信号。
• 等待条件，暂停线程执行。

条件锁体现的是一种协作，一个线程完成后通知其他线程开始执行。Condition variable 必须和 mutex 关联，以避免竞争条件。一个线程获取锁后发现条件不满足，暂停线程执行进行等待，其他线程这时可以获取锁，条件满足后，向条件发出信号。

条件锁可用于生产者、消费者模式中状态同步：

• 0：没有可用数据，消费者需等待。
• 1：产生了新数据，通知消费者。

当消费者发现没有数据时，等待 condition 变为1。生产者生产了新数据，condition 变为1，通知消费者。

这篇文章将介绍三种条件锁：pthread_cond_t、NSCondition和NSConditionLock。

1. pthread_cond_t

前面两篇文章已介绍过pthread_mutex_t和pthread_mutexattr_t，这里需额外使用pthread_cond_t。

1.1 初始化pthread_cond_init()

使用pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr)初始化条件变量 cond，cond_attr 指定的 condition attribute。如果 cond_attr 为 nil，则使用默认属性。pthread_cond_t也可以使用PTHREAD_COND_INITIALIZER常量静态初始化。

如下所示：

    private var mutex = pthread_mutex_t()
    private var cond = pthread_cond_t()
    
    override init() {
        // 初始化属性
        var attr = pthread_mutexattr_t()
        pthread_mutexattr_init(&attr)
        pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE)
        
        // 初始化锁
        pthread_mutex_init(&mutex, &attr)
        
        // 销毁属性
        pthread_mutexattr_destroy(&attr)
        
        // 初始化条件
        pthread_cond_init(&cond, nil)
        
        super.init()
    }

1.2 信号pthread_cond_signal() pthread_cond_broadcast()

pthread_cond_signal()和pthread_cond_broadcast()函数用于解除堵塞在条件变量上的线程。

• pthread_cond_signal()：解除堵塞在条件变量上的一个线程。如果多个线程等待 cond，则唤醒一个线程，但不能指定唤醒的线程。
• pthread_cond_broadcast()：解除堵塞在条件变量上的所有线程。

如果多个线程堵塞在 cond，调度器决定唤醒哪个线程。使用pthread_cond_signal()、pthread_cond_broadcast()唤醒线程后，从pthread_cond_wait()和pthread_cond_timedwait()返回的线程会尝试持有 mutex。如果没有线程等待 cond，则什么也不发生。

    @objc private func addEle() {
        pthread_mutex_lock(&mutex)
        
        data.append("test")
        print("添加了元素")
        
        // 唤醒单个线程
        pthread_cond_signal(&cond)
        
        // 唤醒多个线程
//        pthread_cond_broadcast(&cond)
        
        pthread_mutex_unlock(&mutex)
    }

1.3 等待pthread_cond_wait() pthread_cond_timedwait()

pthread_cond_wait()和pthread_cond_timedwait()函数用于堵塞条件变量。需先使用同一线程锁定 mutex，否则会导致无法预期结果。

解锁 mutex 与在条件变量处挂起线程是原子操作。线程先获取 mutex、后 signal 条件变量，可以避免线程在加锁后、等待条件变量前被唤醒。线程被挂起后不再占用 CPU 时间，直到 signal 条件变量。成功返回后，mutex 被该线程持有。

多个 mutex 并发使用同一个 condition variable 会产生无法预期的结果。也就是当线程等待 condition variable 时， cond 就绑定到了该 mutex。等待结束时，绑定关系终止。

    @objc private func removeEle() {
        pthread_mutex_lock(&mutex)
        
        if data.count == 0 {
            pthread_cond_wait(&cond, &mutex)
        }
        
        data.removeLast()
        print("移除了元素")
        
        pthread_mutex_unlock(&mutex)
    }

pthread_cond_timedwait()与pthread_cond_wait()类似，只是如果指定时间后还没有 signal、broadcast，就返回错误。

1.4 销毁pthread_cond_destroy()

pthread_cond_destroy()销毁指定cond，销毁后对象成为未初始化状态。销毁后的对象可以使用pthread_cond_init()再次初始化，其他方式使用已销毁的对象会产生无法预期的结果。

    deinit {
        pthread_mutex_destroy(&mutex)
        
        pthread_cond_destroy(&cond)
    }

2. NSCondition

NSCondition类是对pthread_mutex_t和pthread_cond_t的封装，为面向对象的类。NSCondition类遵守NSLocking协议。

2.1 初始化NSCondition()

初始化方法如下：

    private var condition = NSCondition()

GNUstep中实现如下：

- (id)init {
    if (nil != (self = [super init])) {
        if (0 != pthread_cond_init(&_condition, NULL)) {
            DESTROY(self);
        } else if (0 != pthread_mutex_init(&_mutex, &attr_reporting)) {
            pthread_cond_destroy(&_condition);
            DESTROY(self);
        }
    }
    return self;
}

2.2 信号signal() broadcast()

signal()一次唤醒一个线程，可以多次调用唤醒多个线程。broadcast()一次唤醒多个线程。

如果没有线程等待cond，则不执行任何操作。为避免竞争条件，应只在 condtion 锁定时调用。

    @objc private func addEle() {
        condition.lock()
        
        data.append("pro648")
        print("添加了元素")
        
        // 唤醒单个线程
        condition.signal()
        
        // 唤醒多个线程
//        condition.broadcast()
        
        condition.unlock()
    }

GNUstep 中实现如下：

- (void) signal
{
    pthread_cond_signal(&_condition);
}

- (void) broadcast
{
    pthread_cond_broadcast(&_condition);
}

2.3 等待wait() wait(until:)

堵塞当前线程，直到 signal 或到达指定时间。必须先 lock NSCondition再调用该方法。

    @objc private func removeEle() {
        condition.lock()
        
        if data.count == 0 {
            condition.wait()
        }
        
        data.removeLast()
        print("移除了元素")
        
        condition.unlock()
    }

GNUstep 中实现如下：

- (void) wait
{
    pthread_cond_wait(&_condition, &_mutex);
}

3. NSConditionLock

NSConditionLock类是对pthread_mutex_t和pthread_cond_t的封装，为面向对象的类，方。NSConditionLock类遵守NSLocking协议。

NSConditionLock有一个关联值，即condition。在初始化NSConditionLock或释放锁时设置。线程会等待锁，直到其为特定值，等待期间不会占用 CPU 时间。借助NSConditionLock condition值可以实现依赖项，使其按次序执行。

3.1 初始化NSConditionLock()

初始化方法如下：

    private var conditionLock = NSConditionLock.init(condition: 1)

GNUstep 中实现如下：

- (id) init
{
    return [self initWithCondition: 0];
}

- (id) initWithCondition: (NSInteger)value
{
    if (nil != (self = [super init])) {
        if (nil == (_condition = [NSCondition new])) {
            DESTROY(self);
        } else {
            _condition_value = value;
            [_condition setName:[NSString stringWithFormat: @"condition-for-lock-%p", self]];
        }
    }
    return self;
}

3.2 加锁lock(whenCondition:)

当NSConditionLock的condition值与lock(whenCondition:)参数的值相同时，加锁成功，否则会堵塞在当前位置。

        conditionLock.lock(whenCondition: 1)

NSConditionLock还有lock(before:)、lock(whenCondition:before:、try()、tryLock(whenCondition:)四种加锁方式。

GNUstep 中实现如下：

- (void) lockWhenCondition: (NSInteger)value
{
    [_condition lock];
    while (value != _condition_value) {
        [_condition wait];
    }
}

3.3 解锁unlock(withCondition:)

释放锁，并设置 condition 值。

    override func otherTest() {
        Thread.init(target: self, selector: #selector(one), object: nil).start()
        Thread.init(target: self, selector: #selector(two), object: nil).start()
        Thread.init(target: self, selector: #selector(three), object: nil).start()
    }
    
    @objc private func one() {
        conditionLock.lock(whenCondition: 1)
        
        data.append("pro648")
        print("one:\(data)")
        
        conditionLock.unlock(withCondition: 2)
    }
    
    @objc private func two() {
        conditionLock.lock(whenCondition: 2)
        
        data.removeLast()
        print("two:\(data)")
        
        conditionLock.unlock(withCondition: 3)
    }
    
    @objc private func three() {
        conditionLock.lock(whenCondition: 3)
        
        data.append("pro648")
        print("three:\(data)")
        
        conditionLock.unlock()
    }

现在，上述三个方法按顺序执行。

GNUstep 中实现如下：

- (void) unlockWithCondition: (NSInteger)value
{
    _condition_value = value;
    [_condition broadcast];
    [_condition unlock];
}

Demo名称：Synchronization
源码地址：https://github.com/pro648/BasicDemos-iOS/tree/master/Synchronization

上一篇：线程同步之递归锁

下一篇：线程同步之读写锁

参考资料：

1. PTHREAD_COND

2. pthread_cond_init, pthread_cond_destroy

3. pthread_cond_signal, pthread_cond_broadcast

4. pthread_cond_wait, pthread_cond_timedwait

欢迎更多指正：https://github.com/pro648/tips

本文地址：https://github.com/pro648/tips/blob/master/sources/线程同步之条件锁.md