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),避免了多个线程同时访问共享资源导致的数据竞争和冲突。
使用互斥锁的一般流程是:
- 线程A想进入临界区,先获取互斥锁。
- 如果互斥锁被线程B持有,线程A会阻塞等待。
- 线程B使用完共享资源后,解锁释放互斥锁。
- 线程A获得互斥锁,进入临界区执行任务。
- 线程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方法为线程安全。但是并不能保证使用属性的过程是线程安全的。
性能比对
