iOS 开发中的八种锁

kklwg
161 阅读10分钟

锁是什么意思？

我们在使用多线程的时候多个线程可能会访问同一块资源，这样就很容易引发数据错乱和数据安全等问题，这时候就需要我们保证每次只有一个线程访问这一块资源，锁 应运而生。

1.OSSpinLock

需导入头文件:

#import <libkern/OSAtomic.h>

__block OSSpinLock oslock = OS_SPINLOCK_INIT;
//线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSLog(@"线程1 准备上锁");
    OSSpinLockLock(&oslock);
    sleep(4);
    NSLog(@"线程1");
    OSSpinLockUnlock(&oslock);
    NSLog(@"线程1 解锁成功");
    NSLog(@"--------------------------------------------------------");
});

//线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSLog(@"线程2 准备上锁");
    OSSpinLockLock(&oslock);
    NSLog(@"线程2");
    OSSpinLockUnlock(&oslock);
    NSLog(@"线程2 解锁成功");
});

运行结果：

**2022-05-26 16:57:36.904881+0800 ChianyuCircle[99935:1611281] 线程2 准备上锁**

**2022-05-26 16:57:36.904881+0800 ChianyuCircle[99935:1611291] 线程1 准备上锁**

**2022-05-26 16:57:36.905006+0800 ChianyuCircle[99935:1611281] 线程2**

**2022-05-26 16:57:36.905106+0800 ChianyuCircle[99935:1611281] 线程2 解锁成功**

**2022-05-26 16:57:40.906263+0800 ChianyuCircle[99935:1611291] 线程1**

**2022-05-26 16:57:40.906442+0800 ChianyuCircle[99935:1611291] 线程1 解锁成功**

**2022-05-26 16:57:40.906526+0800 ChianyuCircle[99935:1611291] --------------------------------------------------------**

2.dispatch_semaphore 信号量

dispatch_semaphore_t signal = dispatch_semaphore_create(1); //传入值必须 >=0, 若传入为0则阻塞线程并等待timeout,时间到后会执行其后的语句
dispatch_time_t overTime = dispatch_time(DISPATCH_TIME_NOW, 3.0f * NSEC_PER_SEC);

//线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSLog(@"线程1 等待ing");
    dispatch_semaphore_wait(signal, overTime); //signal 值 -1
    NSLog(@"线程1");
    dispatch_semaphore_signal(signal); //signal 值 +1
    NSLog(@"线程1 发送信号");
    NSLog(@"--------------------------------------------------------");
});

//线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSLog(@"线程2 等待ing");
    dispatch_semaphore_wait(signal, overTime);
    NSLog(@"线程2");
    dispatch_semaphore_signal(signal);
    NSLog(@"线程2 发送信号");
});

dispatch_semaphore_create(1)：  传入值必须 >=0, 若传入为 0 则阻塞线程并等待timeout,时间到后会执行其后的语句
dispatch_semaphore_wait(signal, overTime)： 可以理解为 lock,会使得 signal 值 -1
dispatch_semaphore_signal(signal)： 可以理解为 unlock,会使得 signal 值 +1

关于信号量，我们可以用停车来比喻：

停车场剩余4个车位，那么即使同时来了四辆车也能停的下。如果此时来了五辆车，那么就有一辆需要等待。
信号量的值（signal） 就相当于剩余车位的数目，dispatch_semaphore_wait 函数就相当于来了一辆车，dispatch_semaphore_signal 就相当于走了一辆车。停车位的剩余数目在初始化的时候就已经指明了（dispatch_semaphore_create（long value）），调用一次 dispatch_semaphore_signal，剩余的车位就增加一个；调用一次dispatch_semaphore_wait 剩余车位就减少一个；当剩余车位为 0 时，再来车（即调用 dispatch_semaphore_wait）就只能等待。有可能同时有几辆车等待一个停车位。有些车主没有耐心，给自己设定了一段等待时间，这段时间内等不到停车位就走了，如果等到了就开进去停车。而有些车主就像把车停在这，所以就一直等下去。

运行结果：

**2022-05-26 17:04:16.955724+0800 ChianyuCircle[166:1618349] 线程2 等待ing**

**2022-05-26 17:04:16.955739+0800 ChianyuCircle[166:1618348] 线程1 等待ing**

**2022-05-26 17:04:16.956184+0800 ChianyuCircle[166:1618348] 线程1**

**2022-05-26 17:04:16.956249+0800 ChianyuCircle[166:1618349] 线程2**

**2022-05-26 17:04:16.957211+0800 ChianyuCircle[166:1618348] 线程1 发送信号**

**2022-05-26 17:04:16.957536+0800 ChianyuCircle[166:1618349] 线程2 发送信号**

**2022-05-26 17:04:16.958081+0800 ChianyuCircle[166:1618348] --------------------------------------------------------**

3.pthread_mutex

使用需导入头文件：

#import <pthread.h>

static pthread_mutex_t pLock;
pthread_mutex_init(&pLock, NULL);
 //1.线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSLog(@"线程1 准备上锁");
    pthread_mutex_lock(&pLock);
    sleep(3);
    NSLog(@"线程1");
    pthread_mutex_unlock(&pLock);
});

//1.线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSLog(@"线程2 准备上锁");
    pthread_mutex_lock(&pLock);
    NSLog(@"线程2");
    pthread_mutex_unlock(&pLock);
});

运行结果:

**2022-05-26 17:07:29.550254+0800 ChianyuCircle[252:1623797] 线程1**

**2022-05-26 17:07:26.549943+0800 ChianyuCircle[252:1623825] 线程2 准备上锁**

**2022-05-26 17:07:26.549942+0800 ChianyuCircle[252:1623797] 线程1 准备上锁**

**2022-05-26 17:07:26.550063+0800 ChianyuCircle[252:1623825] 线程2**

pthread_mutex 中也有个pthread_mutex_trylock(&pLock)，和上面提到的 OSSpinLockTry(&oslock)区别在于，前者可以加锁时返回的是 0，否则返回一个错误提示码；后者返回的 YES和NO

  • pthread_mutex(recursive)

经过上面几种例子，我们可以发现：加锁后只能有一个线程访问该对象，后面的线程需要排队，并且 lock 和 unlock 是对应出现的，同一线程多次 lock 是不允许的，而递归锁允许同一个线程在未释放其拥有的锁时反复对该锁进行加锁操作。

static pthread_mutex_t pLock;
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr); //初始化attr并且给它赋予默认
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); //设置锁类型，这边是设置为递归锁
pthread_mutex_init(&pLock, &attr);
pthread_mutexattr_destroy(&attr); //销毁一个属性对象，在重新进行初始化之前该结构不能重新使用

//1.线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    static void (^RecursiveBlock)(int);
    RecursiveBlock = ^(int value) {
        pthread_mutex_lock(&pLock);
        if (value > 0) {
            NSLog(@"value: %d", value);
            RecursiveBlock(value - 1);
        }
        pthread_mutex_unlock(&pLock);
    };
    RecursiveBlock(5);
});

运行结果:

**2022-05-26 17:10:19.924028+0800 ChianyuCircle[357:1628882] value: 5**

**2022-05-26 17:10:19.924141+0800 ChianyuCircle[357:1628882] value: 4**

**2022-05-26 17:10:19.924232+0800 ChianyuCircle[357:1628882] value: 3**

**2022-05-26 17:10:19.924340+0800 ChianyuCircle[357:1628882] value: 2**

**2022-05-26 17:10:19.924438+0800 ChianyuCircle[357:1628882] value: 1**

上面的代码如果我们用 pthread_mutex_init(&pLock, NULL) 初始化会出现死锁的情况，递归锁能很好的避免这种情况的死锁

4.NSLock

NSLock API 很少也很简单:

lock、unlock：不多做解释，和上面一样
trylock：能加锁返回 YES 并执行加锁操作，相当于 lock，反之返回 NO
** lockBeforeDate：这个方法表示会在传入的时间内尝试加锁，若能加锁则执行加锁**操作并返回 YES，反之返回 NO

例子:

NSLock *lock = [NSLock new];
//线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSLog(@"线程1 尝试加速ing...");
    [lock lock];
    sleep(3);//睡眠5秒
    NSLog(@"线程1");
    [lock unlock];
    NSLog(@"线程1解锁成功");
});

//线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSLog(@"线程2 尝试加速ing...");
    BOOL x =  [lock lockBeforeDate:[NSDate dateWithTimeIntervalSinceNow:4]];
    if (x) {
        NSLog(@"线程2");
        [lock unlock];
    }else{
        NSLog(@"失败");
    }
});

运行结果:

**2022-05-26 17:14:25.702715+0800 ChianyuCircle[507:1634523] 线程1 尝试加速ing...**

**2022-05-26 17:14:25.702753+0800 ChianyuCircle[507:1634532] 线程2 尝试加速ing...**

**2022-05-26 17:14:28.707617+0800 ChianyuCircle[507:1634523] 线程1**

**2022-05-26 17:14:28.707759+0800 ChianyuCircle[507:1634523] 线程1解锁成功**

**2022-05-26 17:14:28.707768+0800 ChianyuCircle[507:1634532] 线程2**

5.NSCondition

API:

wait：进入等待状态
waitUntilDate: ：让一个线程等待一定的时间
signal：唤醒一个等待的线程
broadcast：唤醒所有等待的线程

例子:

  • 等待2秒
NSCondition *cLock = [NSCondition new];
//线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSLog(@"start XXXX");
    [cLock lock];
    [cLock waitUntilDate:[NSDate dateWithTimeIntervalSinceNow:2]];
    NSLog(@"线程1");
    [cLock unlock];
});

结果:

**2022-05-26 17:18:10.582476+0800 ChianyuCircle[627:1640972] start XXXX**
**2022-05-26 17:18:12.585547+0800 ChianyuCircle[627:1640972] 线程1**
  • 唤醒一个等待线程
NSCondition *cLock = [NSCondition new];
//线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    [cLock lock];
    NSLog(@"线程1加锁成功");
    [cLock wait];
    NSLog(@"线程1");
    [cLock unlock];
});

//线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    [cLock lock];
    NSLog(@"线程2加锁成功");
    [cLock wait];
    NSLog(@"线程2");
    [cLock unlock];
});

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    sleep(2);
    NSLog(@"唤醒一个等待的线程");
    [cLock signal];
});

结果:

**2022-05-26 17:20:04.268100+0800 ChianyuCircle[673:1644854] 线程1加锁成功**

**2022-05-26 17:20:04.268265+0800 ChianyuCircle[673:1644856] 线程2加锁成功**

**2022-05-26 17:20:06.139806+0800 ChianyuCircle[673:1644857] 唤醒一个等待的线程**

**2022-05-26 17:20:06.309890+0800 ChianyuCircle[673:1644854] 线程1**
  • 唤醒所有等待的线程
.........    
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    sleep(2);
    NSLog(@"唤醒所有等待的线程");
    [cLock broadcast];
});

结果:

**2022-05-26 17:20:04.268100+0800 ChianyuCircle[673:1644854] 线程1加锁成功**

**2022-05-26 17:20:04.268265+0800 ChianyuCircle[673:1644856] 线程2加锁成功**

**2022-05-26 17:20:06.139806+0800 ChianyuCircle[673:1644857] 唤醒所有等待的线程*

**2022-05-26 17:20:06.309890+0800 ChianyuCircle[673:1644854] 线程1**

**2022-05-26 17:20:06.309890+0800 ChianyuCircle[673:1644854] 线程2**

6.NSRecursiveLock

上面已经大概介绍过了：
递归锁可以被同一线程多次请求，而不会引起死锁。这主要是用在循环或递归操作中。

例子：

NSLock *rLock = [NSLock new];
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    static void (^RecursiveBlock)(int);
    RecursiveBlock = ^(int value) {
        [rLock lock];
        if (value > 0) {
            NSLog(@"线程%d", value);
            RecursiveBlock(value - 1);
        }
        [rLock unlock];
    };
    RecursiveBlock(4);
});

结果是:

**2022-05-26 17:23:54.168986+0800 ChianyuCircle[761:1649430] 线程4**

这段代码是一个典型的死锁情况。在我们的线程中，RecursiveMethod 是递归调用的。所以每次进入这个 block 时，都会去加一次锁，而从第二次开始，由于锁已经被使用了且没有解锁，所以它需要等待锁被解除，这样就导致了死锁，线程被阻塞住了。

将 NSLock 替换为 NSRecursiveLock：

NSRecursiveLock *rLock = [NSRecursiveLock new];
..........

运行结果:

**2022-05-26 17:23:54.168986+0800 ChianyuCircle[761:1649430] 线程4**
**2022-05-26 17:23:54.168986+0800 ChianyuCircle[761:1649430] 线程3**
**2022-05-26 17:23:54.168986+0800 ChianyuCircle[761:1649430] 线程2**
**2022-05-26 17:23:54.168986+0800 ChianyuCircle[761:1649430] 线程1**

NSRecursiveLock 方法里还提供了两个方法，用法和上面介绍的基本没什么差别，这里不过多介绍了：

- (BOOL)tryLock;
- (BOOL)lockBeforeDate:(NSDate *)limit;

7.@synchronized

@synchronized 相信大家应该都熟悉，它的用法应该算这些锁中最简单的:

//线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    @synchronized (self) {
        sleep(2);
        NSLog(@"线程1");
    }
});

//线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    @synchronized (self) {
        NSLog(@"线程2");
    }
});

运行结果:

**2022-05-26 17:27:51.879245+0800 ChianyuCircle[855:1655150] 线程1**

**2022-05-26 17:27:51.879437+0800 ChianyuCircle[855:1655140] 线程2**

有兴趣可以看一下这篇文章 《 关于 @synchronized，这儿比你想知道的还要多》

8.NSConditionLock 条件锁

API: 相比于 NSLock 多了个 condition 参数，我们可以理解为一个条件标示。

NSConditionLock *cLock = [[NSConditionLock alloc] initWithCondition:0];

//线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    if([cLock tryLockWhenCondition:0]){
        NSLog(@"线程1");
       [cLock unlockWithCondition:1];
    }else{
         NSLog(@"失败");
    }
});

//线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    [cLock lockWhenCondition:3];
    NSLog(@"线程2");
    [cLock unlockWithCondition:2];
});

//线程3
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    [cLock lockWhenCondition:1];
    NSLog(@"线程3");
    [cLock unlockWithCondition:3];
});

运行结果:

**2022-05-26 17:27:51.879245+0800 ChianyuCircle[855:1655150] 线程1**

**2022-05-26 17:27:51.879437+0800 ChianyuCircle[855:1655140] 线程3**

**2022-05-26 17:27:51.879437+0800 ChianyuCircle[855:1655140] 线程2**

  • 我们在初始化 NSConditionLock 对象时，给了他的标示为 0

  • 执行 tryLockWhenCondition:时，我们传入的条件标示也是 0,所 以线程1 加锁成功

  • 执行 unlockWithCondition:时，这时候会把condition由 0 修改为 1

  • 因为condition 修改为了  1， 会先走到 线程3，然后 线程3 又将 condition 修改为 3

  • 最后 走了 线程2 的流程

从上面的结果我们可以发现，NSConditionLock 还可以实现任务之间的依赖。

avatar
文章
阅读
粉丝