iOS 多线程下的不同锁

1. 概述

在计算机中，锁是在执行多线程时用于强行限制资源访问的同步机制，即用于在并发控制中保证对互斥要求的满足。 --维基百科

可以通俗的理解为:锁是用来处理多线程下产生数据竞争问题的解决方案

iOS中锁主要可以分为以下几种类型：

  • 自旋锁： OSSpinkLock、os_unfair_lock
  • 互斥锁： NSLock、 pthread_mutex
  • 条件锁： NSCondition、NSConditionLock
  • 递归锁： NSRecursiveLock、@synchronized
  • 读写锁： pthread_rw、dispatch_barrier_asyc
  • 信号量： dispatch_semaphore
  • 原子属性：atomic

2. 应用与详解

2.1 自旋锁

自旋锁会在线程不休眠的情况下重复轮询去获取锁，直到获取到锁。自旋锁常用于多处理器系统上，且其中锁的预期等待时间很小。因为阻塞线程和唤醒涉及上下文切换和线程数据结构的更新，在cpu资源宽裕且锁预期等待时间很短的情况下，轮询通常比阻塞线程更有效。

2.1.1 OSSpinkLock

用法：

   OSSpinLock spinLock = OS_SPINKLOCK_INIT;
   OSSpinLockLock(&spinLock);
    //code
   OSSpinLockUnlock(&spinLock);

存在问题：OSSSpinLock存在优先级反转问题，具体来说，如果一个低优先级的线程获得锁并访问共享资源，这时一个高优先级的线程也尝试获得这个锁，它会处于 spin lock 的忙等状态从而占用大量 CPU。所以在iOS10后被官方废弃了

2.1.2 os_unfair_lock

用法：

 os_unfair_lock_t unfairLock;
 unfairLock = &(OS_UNFAIR_LOCK_INIT);
 
 os_unfair_lock_lock(unfairLock);
 //code
 os_unfair_lock_unlock(unfairLock);

os_unfair_lock的特点是:

非公平锁 - 先对锁请求的线程不一定先获得锁,后请求的线程也有机会直接获取锁,没有队列顺序。
自旋锁 - 不会导致线程睡眠,获取不到锁就不断重试,缩短等待时间,适合锁时间非常短的场景。
快速 - 锁的获取和释放都基于原子操作,速度很快。
轻量级 - 只包含一个指针大小的空间,性能开销小。
递归 - 支持递归获取同一锁。

2.2 互斥锁

互斥锁(Mutex)是一种常用的线程同步机制,它具有以下两个主要特征:

  • 互斥性:每个互斥锁同一时间只能被一个线程持有。
  • 互锁性:线程获取锁前会被阻塞,直到持有锁的线程释放锁。

互斥锁保证了同一时间只有一个线程可以进入临界区(CRITICAL SECTION),避免了多个线程同时访问共享资源导致的数据竞争和冲突。

使用互斥锁的一般流程是:

  1. 线程A想进入临界区,先获取互斥锁。
  2. 如果互斥锁被线程B持有,线程A会阻塞等待。
  3. 线程B使用完共享资源后,解锁释放互斥锁。
  4. 线程A获得互斥锁,进入临界区执行任务。
  5. 线程A完成任务后,也释放互斥锁,让其他阻塞线程继续获取锁。

互斥锁保证了同一时间只有一个线程进入临界区,实现了对共享资源的互斥访问。

2.2.1 NSLock

用法：

NSLock *lock = [NSLock new];
[lock lock];
//code
[lock unlock];

NSLock 内部封装了一个 pthread_mutex，属性为 PTHREAD_MUTEX_ERRORCHECK，它会损失一定性能换来错误提示。

2.2.2 pthread_mutex

用法：

pthread_mutex_t _lock;
pthread_mutex_init(&_lock, NULL);//初始化
pthread_mutex_lock(&_lock)
//code
pthread_mutex_unlock(&_lock) 
pthread_mutex_destroy(&_lock)//释放

原理：mutex底层有实现一个阻塞队列，如果当前有其他任务正在执行，则加入到队列中，放弃当前cpu时间片。一旦其他任务执行完，则从队列中取出等待执行的线程对象，恢复上下文重新执行。

2.3 条件锁

条件锁(Condition Variable)是一种线程同步的机制,经常与互斥锁配合使用。
它具有以下特点:

  • 可以使线程等待某个条件,并在条件满足时接收通知。
  • 支持线程之间的通知与协调,可以实现复杂的等待逻辑。
  • 需要配合互斥锁,保护共享资源。

使用条件锁的流程:

  • 线程使用互斥锁锁住共享资源。
  • 调用Wait方法释放锁并等待。
  • 其他线程获取互斥锁,修改条件。
  • 通知等待线程,条件满足。
  • 等待线程重新竞争互斥锁,检查条件。

所以条件锁允许线程等待某个条件满足后再继续执行,实现了复杂的线程同步,比互斥锁更灵活。

2.3.1 NSCondition

用法：

NSCondition *condition = [NSCondition new];


-(void) crateConsumenr{
  [condition lock];
      while(self.products.count == 0){
         NSLog(@"等待产品");
         [condition wait];
     }
    [self.products removeObject:0];
      NSLog(@"消费产品");
     [condition unlock];
}


-(void)createProducter{
   [condition lock];
     [self.products addObject:[[NSObject alloc] init]];
    NSLog(@"生产了一个产品");
    [condition signal];
    [condition unlock];
}


   [NSThread detachNewThreadSelector:@selector(createConsumenr) toTarget:self withObject:nil];
   [NSThread detachNewThreadSelector:@selector(createProducter) toTarget:self withObject:nil];

NSCondition对象实际上作为一个锁和一个线程检查器：锁主要为了当检测条件时保护数据源，执行条件引发的任务；线程检查器主要是根据条件决定是否继续运行线程，即线程是否被阻塞。通俗的说，也就是条件成立，才会执行锁住的代码。条件不成立时，线程就会阻塞，直到另一个线程向条件对象发出信号解锁为止

2.3.2 NSConditionLock

用法：

- (void)conditionLockTest {
    NSConditionLock *conditionLock = [[NSConditionLock alloc] initWithCondition:2];
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
       [conditionLock lockWhenCondition:1];
       NSLog(@"线程1");
       [conditionLock unlockWithCondition:0];
    });
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0), ^{
       [conditionLock lockWhenCondition:2];
       NSLog(@"线程2");
       [conditionLock unlockWithCondition:1];
    });
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
       [conditionLock lock];
       NSLog(@"线程3");
       [conditionLock unlock];
    });
}

// 打印 线程3->线程2->线程1

NSConditionLock 是NSCondition的一层封装，其自带了判断条件，只有unlock时value值和等待值是一致的时候，才会执行锁定的代码。NSCondition是需要手动让线程进入等待状态阻塞线程、释放信号唤醒线程，NSConditionLock则只需要外部传入一个值，就会依据这个值进行自动判断是阻塞线程还是唤醒线程。

2.4 递归锁

递归锁(Recursive Lock)又称重入锁,是一种支持重复获取的互斥锁。

它的特点是:

  • 同一个线程在外层函数获得锁后,在进入内层函数时可以再次获取该锁。
  • 不会因为多次获取锁而产生死锁。
  • 锁的最终释放次数与获取次数匹配。
  • 一个线程获取锁后,其他线程仍需要等待。
2.4.1 NSRecursiveLock

用法：

@interface LockTest ()
@property (nonatomic, strong) NSRecursiveLock *lock;
@property (nonatomic, assign) int value;
@end

@implementation LockTest
- (void)startTest {
    self.lock = NSRecursiveLock.new;
    [NSThread detachNewThreadSelector:@selector(conditionLockTest) toTarget:self withObject:nil];
}

- (void)conditionLockTest {
    [self.lock lock];
    self.value += 1;
    NSLog(@"%@",@(self.value));
    if (self.value < 5) {
        [self conditionLockTest];
    }
    [self.lock unlock];
}
@end
// 打印 1 2 3 4 5 不会死锁

NSRecursiveLock是对pthread_mutex递归锁的封装，API跟NSLock基本一致

2.4.2 @synchronized

用法：

- (void)test {
    @synchronized ([self class]) {
        //code
    }
}

@synchronized是对pthread_mutex递归锁的封装， @synchronized(obj)内部会生成obj对应的递归锁，然后进行加锁、解锁操作

2.5 读写锁

读写锁(Reader-Writer Lock)是一种用于解决读写冲突的线程同步机制。它具有以下特点:

  • 多个线程可以同时获得读锁,实现并发读。
  • 写线程请求写锁时,会阻塞其他写线程和读线程。
  • 写线程释放写锁后,等待的写线程和读线程才能继续。
  • 读线程不会阻塞读线程,只阻塞写线程。
  • 优化了多读少写场景下的访问效率。

读写锁通常使用场景:

  • 数据库的读写分离,允许并发读,串行写。
  • 缓存器的读写,缓存miss时只有一个线程去创建缓存。
  • 日志或消息收集,并发读,串行写和刷新。

实现读写锁的技术包括:

  • 共享读锁/独占写锁
  • 信号量机制
  • 互斥量和条件变量

读写锁适合读多写少的场景,可以大幅提高效率。但写操作需要独占,要注意优先级反转问题。

2.5.1 pthread_rwlock

用法：

//初始化锁
pthread_rwlock_t lock;
pthread_rwlock_init(&_lock, NULL);

//读加锁
pthread_rwlock_rdlock(&_lock);
//读尝试加锁
pthread_rwlock_trywrlock(&_lock)

//写加锁
pthread_rwlock_wrlock(&_lock);
//写尝试加锁
pthread_rwlock_trywrlock(&_lock)

//解锁
pthread_rwlock_unlock(&_lock);
//销毁
pthread_rwlock_destroy(&_lock);

Demo:

#import <pthread.h>
@interface pthread_rwlockDemo ()
@property (assign, nonatomic) pthread_rwlock_t lock;
@end

@implementation pthread_rwlockDemo

- (instancetype)init
{
self = [super init];
if (self) {
// 初始化锁
pthread_rwlock_init(&_lock, NULL);
}
return self;
}

- (void)otherTest{
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);

for (int i = 0; i < 10; i++) {
dispatch_async(queue, ^{
[self read];
});
dispatch_async(queue, ^{
[self write];
});
}
}
- (void)read {
pthread_rwlock_rdlock(&_lock);
sleep(1);
NSLog(@"%s", __func__);
pthread_rwlock_unlock(&_lock);
}
- (void)write
{
pthread_rwlock_wrlock(&_lock);
sleep(1);
NSLog(@"%s", __func__);
pthread_rwlock_unlock(&_lock);
}
- (void)dealloc
{
pthread_rwlock_destroy(&_lock);
}
@end
2.5.2 dispatch_barrier_async

dispatch_barrier_async 是GCD中的api， 它的特点是：

  • 在并发队列中插入一个执行barrier,阻塞队列中当前并发执行的任务。
  • 当barrier任务执行完成后,队列才会继续执行后续任务。
  • 如果队列中当前没有任务在执行,则barrier任务会直接执行。
  • barrier任务本身仍然会并发执行。
  • 在串行队列中,barrier没有任何效果。
    在并发队列中插入个barrier，会阻塞队列当前并发执行的任务的特点，可以实现读写锁。
    用法：
//初始化
self.queue = dispatch_queue_create("rw_queue", DISPATCH_QUEUE_CONCURRENT);
//读操作
dispatch_async(self.queue, ^{
});
//写操作
dispatch_barrier_async(self.queue, ^{
 
});

2.6 信号量

用法：

@interface Test()
@property (strong, nonatomic) dispatch_semaphore_t semaphore;
@end
@implementation Test
- (instancetype)init {
    if (self = [super init]) {
        self.semaphore = dispatch_semaphore_create(1);
    }
    return self;
}
- (void)otherTest {
    for (int i = 0; i < 20; i++) {
        [[[NSThread alloc] initWithTarget:self selector:@selector(test) object:nil] start];
    }
}
- (void)test {
    dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);

    sleep(2);
    NSLog(@"test - %@", [NSThread currentThread]);
    dispatch_semaphore_signal(self.semaphore);
}
@end

信号量 dispatch_semaphore 初始化的时候可以传入一个value，这个值可以用过来控制线程访问的最大并发数，当设置为1时就可以，保证要保护的代码只有一个线程访问。

2.7 原子属性

用法：

@property (assign, atomic) BOOL test;

使用@proterty 声明时，使用atomic关键字，就能保证这个属性的setter和getter方法为线程安全。但是并不能保证使用属性的过程是线程安全的。

性能比对

image.png
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

相关阅读更多精彩内容

友情链接更多精彩内容