性能
先参考一张 ibireme 大神的图：
自旋锁
自旋锁不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里看是否该自旋锁的保持者已经释放了锁。自旋锁适合于保持时间非常短的情况，自旋锁保持期间是抢占失效的。
内核保证 spin_lock() 和 spin_unlock() 之间的临界区代码在任意时刻只会由一个 CPU 进行访问，并且当前 CPU 访问期间不会发生进程切换，当前进程也不会进入睡眠。
spin_lock();
...临界区...
spin_unlock();
spin_lock()
do {
local_irq_disable();
preempt_disable();
__acquire(lock);
(void)(lock);
} while (0)
local_irq_disable() 关闭中断，preempt_disable() 关闭内核抢占。
spin_unlock()
do {
local_irq_enable();
preempt_enable();
__release(lock);
(void)(lock);
} while (0)
local_irq_enable() 打开中断，preempt_enable() 开启内核抢占。
工作流程
单处理器自旋锁工作流程是：
保存 IF 寄存器 -> 关闭当前 CPU 中断 -> 关闭内核抢占 -> 运行临界区代码 -> 开启内核抢占 -> 开启当前 CPU 中断 -> 恢复 IF 寄存器。
多处理器自旋锁工作流程是：
保存 IF 寄存器 -> 关闭当前 CPU 中断 -> 关闭内核抢占 -> 忙等待 -> 获取自旋锁 -> 运行临界区代码 -> 释放自旋锁 -> 开启内核抢占 -> 开启当前 CPU 中断 -> 恢复 IF 寄存器。
互斥量 Mutex
pthread_mutex_t
用 pthread_once(_:_:) 确保初识话方法在 mutex 使用前可以被调用。
static pthread_once_t once = PTHREAD_ONCE_INIT;
static pthread_mutex_t mutex;
void init() {
pthread_mutex_init(&mutex, NULL);
}
void performWork() {
pthread_once(&once, init); // Correct
pthread_mutex_lock(&mutex);
// ...
pthread_mutex_unlock(&mutex);
}
dispatch_semaphore
基于 dispatch_semaphore 实现了互斥锁：
@interface Lock : NSObject
- (void)lock;
- (void)unlock;
@end
@implementation Lock {
dispatch_semaphore_t _semaphore;
}
- (instancetype)init {
if (self = [super init]) {
_semaphore = dispatch_semaphore_create(1);
}
return self;
}
- (void)lock {
dispatch_semaphore_wait(_semaphore, DISPATCH_TIME_FOREVER);
}
- (void)unlock {
dispatch_semaphore_signal(_semaphore);
}
@end
NSCondition
在给定的线程中扮演一个 lock 和一个 checkpoint。lock 在测试条件时执行由条件触发的任务，从而保护代码。checkpoint 要求在线程继续执行任务之前条件为 true。如果条件不为 true，线程会阻塞，直到另一个线程发出 signal。
作为普通加锁的用法：
NSCondition *lock = [NSCondition new];
[lock lock];
...
[lock unlock];
主要语义：
lock the condition
while (!(boolean_predicate)) {
wait on condition
}
do protected work
(optionally, signal or broadcast the condition again or change a predicate value)
unlock the condition
主要方法：
- (void)wait; // 阻塞当前线程，直至 signal
- (void)signal; // 唤醒等待的线程
典型的就是生产者-消费者问题
- (void)producer {
while (YES) {
[_condition lock];
NSObject *object = [NSObject new];
[_storages addObject: object];
[NSThread sleepForTimeInterval:0.1];
[_condition signal];
[_condition unlock];
}
}
- (void)consumer {
while (YES) {
[_condition lock];
while (self.storages.count <= 0) {
[_condition wait];
}
NSObject *object = [self.storages objectAtIndex:0];
[self.storages removeObject:object];
[_condition unlock];
}
}
NSRecursiveLock
A lock that may be acquired multiple times by the same thread without causing a deadlock.
递归锁在同一个线程多次调用不会产生死锁。
作为普通加锁的用法：
NSRecursiveLock *lock = [NSRecursiveLock new];
[lock lock];
...
[lock unlock];
主要是用在循环或递归操作中。一般，递归锁内部维护着一个 Lock 和一个 counter 变量，counter 记录了 acquire 的次数，从而使得资源可以被多次 require。直到一个线程所有的 acquire 都被 release，其他的线程才能获得资源。
NSRecursiveLock *lock = [[NSRecursiveLock alloc] init];
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
static void (^RecursiveMethod)(int);
RecursiveMethod = ^(int value) {
[lock lock];
if (value > 0) {
NSLog(@"value = %d", value);
sleep(2);
RecursiveMethod(value - 1);
}
[lock unlock];
};
RecursiveMethod(5);
});
区别
从实现原理上来讲，Mutex 属于 sleep-waiting 类型的锁。例如在一个双核的机器上有两个线程( 线程 A 和 线程 B )，它们分别运行在 Core0 和 Core1 上。假设 线程 A 想要通过 pthread_mutex_lock 操作去得到一个临界区的锁，而此时这个锁正被 线程B 所持有，那么 线程A 就会被阻塞(blocking)，Core0 会在此时进行上下文切换(Context Switch)将 线程 A 置于等待队列中，此时 Core0 就可以运行其他的任务(例如另一个 线程 C)而不必进行忙等待。
而 Spin lock 则不然，它属于 busy-waiting 类型的锁，如果 线程 A 是使用 pthread_spin_lock 操作去请求锁，那么 线程 A 就会一直在 Core0 上进行忙等待并不停的进行锁请求，直到得到这个锁为止。
对于自旋锁来说，它只需要消耗很少的资源来建立锁；随后当线程被阻塞时，它就会一直重复检查看锁是否可用了，也就是说当自旋锁处于等待状态时它会一直消耗 CPU 时间。
对于互斥锁来说，与自旋锁相比它需要消耗大量的系统资源来建立锁；随后当线程被阻塞时，线程的调度状态被修改，并且线程被加入等待线程队列；最后当锁可用 时，在获取锁之前，线程会被从等待队列取出并更改其调度状态；但是在线程被阻塞期间，它不消耗 CPU 资源。
因此自旋锁和互斥锁适用于不同的场景。自旋锁适用于那些仅需要阻塞很短时间的场景，而互斥锁适用于那些可能会阻塞很长时间的场景。
