自旋锁与互斥锁

Posted on | In

本文介绍了 iOS 各种加锁方法。

性能

先参考一张 ibireme 大神的图：

自旋锁

自旋锁不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里看是否该自旋锁的保持者已经释放了锁。自旋锁适合于保持时间非常短的情况，自旋锁保持期间是抢占失效的。

内核保证 spin_lock() 和 spin_unlock() 之间的临界区代码在任意时刻只会由一个 CPU 进行访问，并且当前 CPU 访问期间不会发生进程切换，当前进程也不会进入睡眠。

1
2
3
spin_lock();
...临界区...
spin_unlock();

spin_lock()

1
2
3
4
5
6
do { 
    local_irq_disable();
    preempt_disable(); 
    __acquire(lock); 
    (void)(lock); 
    } while (0)

local_irq_disable() 关闭中断，preempt_disable() 关闭内核抢占。

spin_unlock()

1
2
3
4
5
6
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 使用前可以被调用。

1
2
3
4
5
6
7
8
9
10
11
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 实现了互斥锁：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@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。

作为普通加锁的用法：

1
2
3
4
 NSCondition *lock = [NSCondition new];
[lock lock];
...
[lock unlock];

主要语义：

1
2
3
4
5
6
7
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

主要方法：

1
2
- (void)wait; // 阻塞当前线程，直至 signal
- (void)signal; // 唤醒等待的线程

典型的就是生产者-消费者问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
- (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.
递归锁在同一个线程多次调用不会产生死锁。

作为普通加锁的用法：

1
2
3
4
NSRecursiveLock *lock = [NSRecursiveLock new];
[lock lock];
...
[lock unlock];

主要是用在循环或递归操作中。一般，递归锁内部维护着一个 Lock 和一个 counter 变量，counter 记录了 acquire 的次数，从而使得资源可以被多次 require。直到一个线程所有的 acquire 都被 release，其他的线程才能获得资源。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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 资源。

因此自旋锁和互斥锁适用于不同的场景。自旋锁适用于那些仅需要阻塞很短时间的场景，而互斥锁适用于那些可能会阻塞很长时间的场景。