这是并发控制方案的系列文章，介绍了各种锁的使用及优缺点。
OSSpinLock、os_unfair_lock、pthread_mutex_t、pthread_cond_t、pthread_rwlock_t 是值类型，不是引用类型。这意味着使用 = 会进行复制，使用复制的可能导致闪退。pthread 函数认为其一直处于初始化的内存地址，将其移动到其他内存地址会产生问题。使用copy的OSSpinLock不会崩溃，但会得到一个全新的锁。
如果你对线程、进程、串行、并发、并行、锁等概念还不了解，建议先查看以下文章：
条件变量（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
上一篇：线程同步之递归锁
下一篇：线程同步之读写锁
参考资料：
欢迎更多指正：https://github.com/pro648/tips
本文地址：https://github.com/pro648/tips/blob/master/sources/线程同步之条件锁.md
