【iOS】OC底层系列十四 - 多线程-线程安全

多线程安全在开发中是难点，但更是重点。平时生活中的卖票、存取钱等问题都和多线程安全有关。

一、多线程安全分析

卖票示例代码：

// 卖票
- (void)ticketTest {
    self.ticketsCount = 15;
    
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i++) {
             [self saleTicket];
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i++) {
            [self saleTicket];
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i++) {
            [self saleTicket];
        }
    });
}

// 卖1张票
- (void)saleTicket {
    int oldTicketsCount = self.ticketsCount;
    sleep(.2);
    oldTicketsCount--;
    self.ticketsCount = oldTicketsCount;
    
    NSLog(@"还剩%d张票 - %@", oldTicketsCount, [NSThread currentThread]);
}

最终卖出的票比实际票数还多。

存取钱示例代码：

// 存钱、取钱
- (void)moneyTest {
    self.money = 100;
    
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 10; i++) {
            [self saveMoney];
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 10; i++) {
            [self drawMoney];
        }
    });
}

// 存钱
- (void)saveMoney {
    int oldMoney = self.money;
    sleep(.2);
    oldMoney += 50;
    self.money = oldMoney;
    
    NSLog(@"存50，还剩%d元 - %@", oldMoney, [NSThread currentThread]);
}

// 取钱
- (void)drawMoney {
    int oldMoney = self.money;
    sleep(.2);
    oldMoney -= 20;
    self.money = oldMoney;
    
    NSLog(@"取20，还剩%d元 - %@", oldMoney, [NSThread currentThread]);
}

账户上的钱（变量money）和实际存取的数对应不上。

多线程安全隐患分析：

内存中有一个数值17。线程A先把数值17读出来，并做加1操作，然后把结果18写到内存中。在线程A把最新的结果写入内存前，线程B也从内存中把数值读出来了（此处内存中的数值还是17），然后也做了加1操作，把最新的结果写到内存中（最新结果是18）。线程A和线程B都做了加1操作，理论上内存中的值应该是19，但是由于数值没有同步的问题导致数值只被加了一次。

解决方案：使用线程同步技术（同步，就是协同步调，按预定的先后次序进行）。常见的线程同步技术是：加锁。

如果在线程A读写内存中的数值时对数据加锁，其他线程就无法读写内存中的数据。等线程A把数据写到内存中并对数据解锁后，其他线程才可以对数据进行读写（加锁/解锁）操作，这样就能够保证多线程安全。

二、线程同步方案

在iOS中线程同步方案有很多种：

• OSSpinLock（自旋锁）
• os_unfair_lock（用于取代OSSpinLock）
• pthread_mutex（互斥锁）
• dispatch_semaphore（信号量）
• dispatch_queue(DISPATCH_QUEUE_SERIAL)（串行队列）
• NSLock（对pthread_mutex-普通锁的OC版本封装）
• NSRecursiveLock（对pthread_mutex-递归锁的OC版本封装）
• NSCondition（对pthread_mutex-条件的OC版本封装）
• NSConditionLock（对NSCondition的高级封装）
• @synchronized（对pthread_mutex-递归锁的OC版本封装，代码非常简洁，但性能不太好）

加锁的前提：访问的是同一份资源时必须是同一把锁，否则会出现线程不同步。

2.1. OSSpinLock

OSSpinLock叫做自旋锁，等待锁的线程会处于忙等（busy-wait）状态，一直占用着CPU资源。

目前已经不再安全，可能会出现优先级反转问题。如果等待锁的线程优先级较高，它会一直占用着CPU资源，优先级低的线程就无法释放锁。

需要导入头文件#import <libkern/OSAtomic.h>。

// 初始化
OSSpinLock lock = OS_SPINLOCK_INIT;
// 尝试加锁（如果需要等待就不加锁，直接返回false代表加锁失败；如果不需要等待就加锁，返回true代表加锁成功）
bool result = OSSpinLockTry(lock);
// 加锁
OSSpinLockLock(&lock);
// 业务逻辑
// 解锁
OSSpinLockUnlock(&lock);

加锁后一定要解锁，否则会形成死锁（其他线程拿不到锁）。

自旋锁的内部其实就是一个while循环，让线程一直处在循环中等待上一个线程解锁，因此线程并没有在休眠状态。

2.2. os_unfair_lock

OSSpinLock在iOS10.0已经被废弃，官方使用os_unfair_lock取代不安全的OSSpinLock。

typedef int32_t OSSpinLock OSSPINLOCK_DEPRECATED_REPLACE_WITH(os_unfair_lock);

从底层调用看，等待os_unfair_lock锁的线程会处于休眠状态，并非忙等，所以会节省CPU资源。os_unfair_lock的本质其实是一个互斥锁，因为线程等待时会处于休眠状态。

需要导入头文件#import <os/lock.h>。

// 初始化
os_unfair_lock lock = OS_UNFAIR_LOCK_INIT;
// 尝试加锁
os_unfair_lock_trylock(&lock);
// 加锁
os_unfair_lock_lock(&lock);
// 业务逻辑
// 解锁
os_unfair_lock_unlock(&lock);

2.3. pthread_mutex

mutex叫做互斥锁，等待锁的线程会处于休眠状态，不会占用CPU资源。

需要导入头文件#import <pthread.h>。

// 初始化锁的属性
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
// 初始化锁
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, &attr);
// 尝试加锁
pthread_mutex_trylock(&mutex);
// 加锁
pthread_mutex_lock(&mutex);
// 解锁
pthread_mutex_unlock(&mutex);
// 销毁相关资源
pthread_mutexattr_destroy(&attr);
pthread_mutex_destroy(&mutex);

互斥锁的类型：

/*
 * Mutex type attributes
 */
#define PTHREAD_MUTEX_NORMAL	  	0 										// 普通锁
#define PTHREAD_MUTEX_ERRORCHECK	1											// 错误检查
#define PTHREAD_MUTEX_RECURSIVE		2											// 递归锁
#define PTHREAD_MUTEX_DEFAULT		  PTHREAD_MUTEX_NORMAL  // 默认锁（普通锁）

2.3.1. pthread_mutex – 递归锁

如果上面的加锁代码有递归就会发生死锁，因此需要递归锁解决死锁的问题（递归锁：允许同一个线程对一把锁进行重复加锁，所以多线程访问不会造成加锁无效）。

pthread_mutexattr_settype传入PTHREAD_MUTEX_NORMAL就是递归锁。

// 初始化锁的属性
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
// 初始化锁
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, &attr);

2.3.2. pthread_mutex – 条件

// 初始化锁
pthread_mutex_t mutex;
// NULL代表使用默认属性
pthread_mutex_init(&mutex, NULL);
// 初始化条件
pthread_cond_t condition;
pthread_cond_init(&condition, NULL);
// 等待条件（进入休眠，会自动放开mutex锁；被唤醒后，会再次对mutex加锁，并继续执行下面的逻辑）
pthread_cond_wait(&condition, &mutex);
// 激活一个等待该条件的线程
pthread_cond_signal(&condition);
// 激活所有等待该条件的线程
pthread_cond_broadcast(&condition);
// 销毁资源
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&condition);

需求示例：先进入删除数组中的元素的线程时，有可能数组中没有元素，此时应该让线程处于等待状态，往数组添加元素的线程执行完后，可以让删除元素的线程继续执行删除操作。

@interface DBThreadMutex()
  
@property (assign, nonatomic) pthread_mutex_t mutex;
@property (assign, nonatomic) pthread_cond_t cond;
@property (strong, nonatomic) NSMutableArray *data;

@end

@implementation DBThreadMutex

- (instancetype)init {
    if (self = [super init]) {
        // 初始化属性
        pthread_mutexattr_t attr;
        pthread_mutexattr_init(&attr);
        pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
        // 初始化锁
        pthread_mutex_init(&_mutex, &attr);
        // 销毁属性
        pthread_mutexattr_destroy(&attr);
        
        // 初始化条件
        pthread_cond_init(&_cond, NULL);
        
        self.data = [NSMutableArray array];
    }
    return self;
}

// 测试入口
- (void)entryTest {
    [[[NSThread alloc] initWithTarget:self selector:@selector(remove) object:nil] start];
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(add) object:nil] start];
}

// 线程1
// 删除数组中的元素
- (void)remove {
    pthread_mutex_lock(&_mutex);
    
    if (self.data.count == 0) {
        // 等待
        pthread_cond_wait(&_cond, &_mutex);
    }
    
    [self.data removeLastObject];
    
    pthread_mutex_unlock(&_mutex);
}

// 线程2
// 往数组中添加元素
- (void)add {
    pthread_mutex_lock(&_mutex);
    
    sleep(1);
    
    [self.data addObject:@"Test"];
    
    pthread_cond_signal(&_cond);
    
    pthread_mutex_unlock(&_mutex);
}

- (void)dealloc {
    pthread_mutex_destroy(&_mutex);
    pthread_cond_destroy(&_cond);
}

@end

pthread_cond_signal执行结束后，pthread_cond_wait并不会马上自动加锁，而是要等到解锁后才能加锁。

2.4. NSLock、NSRecursiveLock

NSLock是对mutex普通锁的封装。

官方定义的NSLock：

@protocol NSLocking

- (void)lock;
- (void)unlock;

@end
  
@interface NSLock : NSObject <NSLocking> {

// 线程不会等待
- (BOOL)tryLock;
// 线程在时间到期前还是拿不到锁，就会加锁失败（返回NO）
- (BOOL)lockBeforeDate:(NSDate *)limit;

@property (nullable, copy) NSString *name;

@end

使用NSLock初始化锁和初始化普通对象一样：

NSLock *lock = [[NSLock alloc] init];

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

2.5. NSCondition

NSCondition是对mutex和cond的封装。

官方定义的NSCondition：

@interface NSCondition : NSObject <NSLocking> {
  
- (void)wait;
- (BOOL)waitUntilDate:(NSDate *)limit;
- (void)signal;
- (void)broadcast;

@property (nullable, copy) NSString *name;

@end

2.6. NSConditionLock

NSConditionLock是对NSCondition的进一步封装，可以设置具体的条件值。

@interface NSConditionLock : NSObject <NSLocking> {

// 初始化条件（条件值默认是0）
- (instancetype)initWithCondition:(NSInteger)condition NS_DESIGNATED_INITIALIZER;

@property (readonly) NSInteger condition;
// 当条件成立的时候加锁
- (void)lockWhenCondition:(NSInteger)condition;
- (BOOL)tryLock;
- (BOOL)tryLockWhenCondition:(NSInteger)condition;
// 解锁并设条件值（通过这个方法可以设置线程依赖）
- (void)unlockWithCondition:(NSInteger)condition;
- (BOOL)lockBeforeDate:(NSDate *)limit;
- (BOOL)lockWhenCondition:(NSInteger)condition beforeDate:(NSDate *)limit;

@property (nullable, copy) NSString *name;

@end

2.7. dispatch_semaphore

semaphore叫做信号量。信号量的初始值，可以用来控制线程并发访问的最大数量。信号量的初始值为1，代表同时只允许1条线程访问资源，保证线程同步。

// 信号量的初始值
int value = 1;
// 初始化信号量
dispatch_semaphore_t semaphore = dispatch_semaphore_create(value);
// 如果信号量的值<=0，当前线程就会进入休眠等待（直到信号量的值>0）
// 如果信号量的值>0，就减1，然后往下执行后面的代码
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
// 让信号量的值加1
dispatch_semaphore_signal(semaphore);

2.8. dispatch_queue

直接使用GCD的串行队列，也是可以实现线程同步的。

dispatch_queue_t queue = dispatch_queue_create("lock_queue", DISPATCH_QUEUE_SERIAL);
dispatch_sync(queue, ^{
   // 任务
});

2.9. @synchronized

@synchronized是对mutex递归锁的封装。

源码查看：objc中的objc-sync.mm文件。

@synchronized(obj)内部会生成obj对应的递归锁，然后自动进行加锁、解锁操作。由于性能不太好，所以不太建议使用。

@synchronized (obj) {
    // 任务
}

三、线程同步方案性能比较

3.1. 性能从高到低排序

• os_unfair_lock（用于取代OSSpinLock）
• OSSpinLock（自旋锁）
• dispatch_semaphore（信号量）
• pthread_mutex（互斥锁）
• dispatch_queue(DISPATCH_QUEUE_SERIAL)（串行队列）
• NSLock（对pthread_mutex-普通锁的OC版本封装）
• NSCondition（对pthread_mutex-条件的OC版本封装）
• pthread_mutex(recursive)（递归锁）
• NSRecursiveLock（对pthread_mutex-递归锁的OC版本封装）
• NSConditionLock（对NSCondition的高级封装）
• @synchronized（对pthread_mutex-递归锁的OC版本封装，代码非常简洁，但性能不太好）

3.2. 自旋锁、互斥锁比较

什么情况使用自旋锁比较划算？

• 预计线程等待锁的时间很短
• 加锁的代码（临界区）经常被调用，但竞争情况很少发生
• CPU资源不紧张
• 多核处理器

什么情况使用互斥锁比较划算？

• 预计线程等待锁的时间较长
• 单核处理器
• 临界区有IO操作
• 临界区代码复杂或者循环量大
• 临界区竞争非常激烈

四、读写安全方案

4.1. atomic

atomic用于保证属性setter、getter的原子性操作，相当于在setter和getter内部加了线程同步的锁，可以参考源码objc的objc-accessors.mm。但它并不能保证使用属性的过程是线程安全的。

@interface DBPerson : NSObject

@property(atomic, strong) NSMutableArray *array;

@end

DBPerson *person = [[DBPerson alloc] init];
person.array = [NSMutableArray array];

[person.array addObject:@"1"];
[person.array addObject:@"2"];
[person.array addObject:@"3"];

如上代码，array的setter和getter方法内部是线程安全的，但是addObject:方法并不是线程安全的。

atomic比较消耗CPU资源，所以一般情况下在iOS平台很少使用atomic修饰属性。如果对属性有线程安全的要求，完全可以在外部进行加锁和解锁，并且可控。

4.2. 读写锁和栅栏函数

思考如何实现以下场景：

• 同一时间，只能有1个线程进行写的操作
• 同一时间，允许有多个线程进行读的操作
• 同一时间，不允许既有写的操作，又有读的操作

上面的场景就是典型的多读单写，经常用于文件等数据的读写操作，iOS中的实现方案有：

• pthread_rwlock：读写锁
• dispatch_barrier_async：异步栅栏调用

4.2.1. pthread_rwlock

等待锁的线程会进入休眠。

// 初始化锁
pthread_rwlock_t lock;
pthread_rwlock_init(&lock, NULL);
// 读-加锁
pthread_rwlock_rdlock(&lock);
// 读-尝试加锁
pthread_rwlock_tryrdlock(&lock);
// 写-加锁
pthread_rwlock_wrlock(&lock);
// 写-尝试加锁
pthread_rwlock_trywrlock(&lock);
// 解锁
pthread_rwlock_unlock(&lock);
// 销毁
pthread_rwlock_destroy(&lock);

4.2.2. dispatch_barrier_async

这个函数传入的并发队列必须是自己通过dispatch_queue_cretate创建的，如果传入的是一个串行或是一个全局的并发队列，那这个函数便等同于dispatch_async函数的效果。

// 初始化队列
dispatch_queue_t queue = dispatch_queue_create("rw_queue", DISPATCH_QUEUE_CONCURRENT);
// 读
dispatch_async(queue, ^{

});
// 写
dispatch_barrier_async(queue, ^{

});

---

面试题1：你理解的多线程？

面试题2：iOS的多线程方案有哪几种？你更倾向于哪一种？

面试题3：你在项目中用过 GCD 吗？

面试题4：GCD 的队列类型

面试题5：说一下 OperationQueue 和 GCD 的区别，以及各自的优势

面试题6：线程安全的处理手段有哪些？

面试题7：OC你了解的锁有哪些？在你回答基础上进行二次提问；

• 追问一：自旋和互斥对比？
• 追问二：使用以上锁需要注意哪些？
• 追问三：用C/OC/C++，任选其一，实现自旋或互斥？口述即可！