【iOS 底层原理】多线程、线程安全和锁

一、基础概念

有4个术语比较容易混淆：同步、异步、并发、串行

1.进程和线程

进程：进程是计算机中已运行程序的实体，是线程的容器。每个进程之间是相互独立的，每个进程均运行在专用且受保护的内存空间内。 把工厂作为一个系统，进程类似于车间。
线程：线程是操作系统能够进行运算调度的最小单位。一个进程的所有任务都在线程中执行。一个线程中执行的任务是串行的，同一时间内1个线程只能执行一个任务。 把工厂作为一个系统，线程类似于车间里干活的工人。

进程和线程之间关系

• 线程是CPU调用的最小单位
• 进程手机CPU分配资源的最小单位
• 一个进程中至少有一个线程
• 同一个进程内的线程共享进程的资源

多线程：一个进程可以开启多条线程，每条线程可以同时执行不同的任务，多线程技术可以提高程序的执行效率。同一时间内，CPU只能处理1条线程，只有1条线程在工作，多线程并发执行，其实是CPU快速的在多条线程之间调度，如果CPU调度线程的时间足够快，就造成了多线程并发执行的假象。CPU在多条线程之间调度会消耗大量的CPU资源，同时每条线程被调度的频次会降低，因此我们只开辟3-5条线程。

多线程优缺点

• 优点：1、能适当提高程序的执行效率；2、能适当提高资源利用率（CPU,内存利用率）
• 缺点: 1、创建线程的开销，在iOS中，内核数据结构（大约1kb）、栈空间（子线程512kb，主线程1MB）创建线程大约需要90毫秒的创建时间，如果开启大量线程会降低程序性能，线程越多，CPU在调度线程上的开销就越大。

线程的状态

image.png

1. 创建：实例化对象
2. 就绪：向线程对象发送start消息，线程对象被加入 “可调度线程池”，等待CPU调度，detach 方法 和 performSelectorInBackground 方法会直接实例化一个线程对象并加入 “可调度线程池”
3. 运行：CPU 负责调度 “可调度线程池”中线程的执行，线程执行完成之前，状态可能会在 “就绪” 和 “运行” 之间来回切换，此过程CPU控制。
4. 阻塞：当满足某个预定条件时，可以使用休眠或锁阻塞线程执行，影响的方法有：sleepForTimeInterval, sleepUntilDate, @synchronized(self) 线程锁。线程对象进入阻塞状态后，会被“可调度线程池” 中移除，CPU不再调度。
5. 死亡：死亡后线程对象的 isFinished 属性为YES;如果发送cancel消息，线程对象的 isCanceled 属性为YES;死亡后 stackSize == 0, 内存空间被释放。

1.同步和异步

同步和异步主要影响：

• 能不能开启新的线程。
• 会不会阻塞当前线程。

同步：在当前线程中执行任务，不具备开启新线程的能力
异步：在新的线程中执行任务，具备开启新线程的能力（具备开线程的能力，但不一定会开线程）

2.并发和串行

并发和串行主要影响：任务的执行方式

并发：多个任务并发（同时）执行
串行：一个任务执行完毕后，再执行下一个任务

二、多线程方案

image.png

1. GCD

GCD源码：https://github.com/apple/swift-corelibs-libdispatch

同步/异步

GCD中有2个用来执行任务的函数
用同步的方式执行任务
dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);

用异步的方式执行任务
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

队列

GCD的队列可以分为2大类型
并发队列（Concurrent Dispatch Queue）

• 可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）
• 并发功能只有在异步（dispatch_async）函数下才有效

串行队列（Serial Dispatch Queue）

• 让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）

各队列的执行效果

image.png

dispatch :派遣/调度
queue:队列
    用来存放任务的先进先出（FIFO）的容器
sync:同步
    只是在当前线程中执行任务，不具备开启新线程的能力
async:异步
    可以在新的线程中执行任务，具备开启新线程的能力
concurrent:并发
    多个任务并发（同时）执行
串行：
    一个任务执行完毕后，再执行下一个任务

任务

 - queue：队列
 - block：任务
// 1.用同步的方式执行任务
dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);

// 2.用异步的方式执行任务
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

// 3.GCD中还有个用来执行任务的函数
// 在前面的任务执行结束后它才执行，而且它后面的任务等它执行完成之后才会执行
dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);

使用 GCD 死锁的情况

使用sync函数往当前串行队列中添加任务，会卡住当前的串行队列（产生死锁）

队列组

思考：如何用gcd实现以下功能

• 异步并发执行任务1、任务2
• 等任务1、任务2都执行完毕后，再回到主线程执行任务3

image.png

GCD 的其他用法

延时执行

dispatch_after(3.0, dispatch_get_main_queue(), ^{
   /// 延时3秒执行的操作!
});

一次性执行

// 使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    // 只执行1次的代码(这里面默认是线程安全的)
});

队列组

//创建调度组
dispatch_group_t group = dispatch_group_create();
//将调度组添加到队列，执行 block 任务
dispatch_group_async(group, queue, block);
//当调度组中的所有任务执行结束后，获得通知，统一做后续操作
dispatch_group_notify(group, dispatch_get_main_queue(), block);

GCD定时器

dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER,0, 0, DISPATCH_TARGET_QUEUE_DEFAULT);
dispatch_source_set_event_handler(source, ^(){
     NSLog(@"Time flies.");
});
dispatch_time_t start
dispatch_source_set_timer(source, DISPATCH_TIME_NOW, 5ull * NSEC_PER_SEC,100ull * NSEC_PER_MSEC);
self.source = source;
dispatch_resume(self.source);

2.NSOperation

略

3.NSThread

demo

- (void)testNSThread {
    /// 获取当前线程
    NSThread *currentThread = [NSThread currentThread];
    
    /// 创建需要自己启动的线程
    NSThread *creatThread = [[NSThread alloc] initWithTarget:self selector:@selector(runMethod) object:nil];
    [creatThread start];

    /// 创建自动启动的线程
    [NSThread detachNewThreadSelector:@selector(runMethod2) toTarget:self withObject:nil];
}
- (void)runMethod {
    NSLog(@"runMethod ++ %@",[NSThread currentThread]);
}
- (void)runMethod2 {
    NSLog(@"runMethod2 ++ %@",[NSThread currentThread]);
}

相关 API

// 获取当前线程
 + (NSThread *)currentThread;
 // 创建启动线程
 + (void)detachNewThreadSelector:(SEL)selector toTarget:(id)target withObject:(id)argument;
 // 判断是否是多线程
 + (BOOL)isMultiThreaded;
 // 线程休眠 NSDate 休眠到什么时候
 + (void)sleepUntilDate:(NSDate *)date;
 // 线程休眠时间
 + (void)sleepForTimeInterval:(NSTimeInterval)ti;
 // 结束/退出当前线程
 + (void)exit;
 // 获取当前线程优先级
 + (double)threadPriority;
 // 设置线程优先级 默认为0.5 取值范围为0.0 - 1.0 
 // 1.0优先级最高
 // 设置优先级
 + (BOOL)setThreadPriority:(double)p;
 // 获取指定线程的优先级
 - (double)threadPriority NS_AVAILABLE(10_6, 4_0);
 - (void)setThreadPriority:(double)p NS_AVAILABLE(10_6, 4_0);
 // 设置线程的名字
 - (void)setName:(NSString *)n NS_AVAILABLE(10_5, 2_0);
 - (NSString *)name NS_AVAILABLE(10_5, 2_0);
 // 判断指定的线程是否是 主线程
 - (BOOL)isMainThread NS_AVAILABLE(10_5, 2_0);
 // 判断当前线程是否是主线程
 + (BOOL)isMainThread NS_AVAILABLE(10_5, 2_0); // reports whether current thread is main
 // 获取主线程
 + (NSThread *)mainThread NS_AVAILABLE(10_5, 2_0);
 - (id)init NS_AVAILABLE(10_5, 2_0);    // designated initializer
 // 创建线程
 - (id)initWithTarget:(id)target selector:(SEL)selector object:(id)argument NS_AVAILABLE(10_5, 2_0);
 // 指定线程是否在执行
 - (BOOL)isExecuting NS_AVAILABLE(10_5, 2_0);
 // 线程是否完成
 - (BOOL)isFinished NS_AVAILABLE(10_5, 2_0);
 // 线程是否被取消 (是否给当前线程发过取消信号)
 - (BOOL)isCancelled NS_AVAILABLE(10_5, 2_0);
 // 发送线程取消信号的 最终线程是否结束 由 线程本身决定
 - (void)cancel NS_AVAILABLE(10_5, 2_0);
 // 启动线程
 - (void)start NS_AVAILABLE(10_5, 2_0);
 // 线程主函数  在线程中执行的函数 都要在-main函数中调用，自定义线程中重写-main方法
 - (void)main NS_AVAILABLE(10_5, 2_0);    // thread body metho

线程间通信

//在主线程上执行操作，例如给UIImageVIew设置图片
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait
//在指定线程上执行操作
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thread withObject:(id)arg waitUntilDone:(BOOL)wait

三、线程安全方案（锁）

多线程的安全隐患：一块资源可能会被多个线程共享，也就是多个线程可能会访问同一块资源

比如多个线程访问同一个对象、同一个变量、同一个文件

当多个线程访问同一块资源时，很容易引发数据错乱和数据安全问题

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

1.iOS 中的线程同步方案

• OSSpinLock
• os_unfair_lock
• pthread_mutex
• dispatch_semaphore
• dispatch_queue(DISPATCH_QUEUE_SERIAL)
• NSLock
• NSRecursiveLock
• NSCondition
• NSConditionLock
• @synchronized

2.OSSpinLock

OSSpinLock叫做”自旋锁”，等待锁的线程会处于忙等（busy-wait）状态，一直占用着CPU资源。（目前已经不再安全，可能会出现优先级反转问题）

优先级：优先级低的线程先获取锁，而等待锁的线程优先级较高，它会一直占用着CPU资源，优先级低的线程可能一直无法获得时间片，进而无法释放锁

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

image.png

3.os_unfair_lock

os_unfair_lock 用于取代不安全的 OSSpinLock ，从 iOS10 开始才支持

从底层调用看，等待 os_unfair_lock 锁的线程会处于休眠状态，并非忙等

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

image.png

4.pthread_mutex

mutex叫做”互斥锁”，等待锁的线程会处于休眠状态

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

image.png

pthread_mutex 递归锁实现

image.png

pthread_mutex 条件锁实现

image.png

demo

- (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)otherTest
{
    [[[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);
    NSLog(@"__remove - begin");
    
    if (self.data.count == 0) {
        // 等待
        pthread_cond_wait(&_cond, &_mutex);
    }
    
    [self.data removeLastObject];
    NSLog(@"删除了元素");
    
    pthread_mutex_unlock(&_mutex);
}

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

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

remove 方法先获得锁，这时 count ==0 触发等待（pthread_cond_wait），释放锁，add 方法得以执行，在条件满足时，调用 pthread_cond_signal 唤醒之前 wait 的线程。

pthread_cond_wait 的含义

1. 当条件 &_cond 不满足时，释放锁；从而其他线程可以获得锁
2. 当前线程休眠
3. 当条件 &_cond 满足时，重新获得锁

适用场景：类似生产者-消费者模型

5.dispatch_semaphore

image.png

类似 NSOperationQueue 的 maxConcurrentOperationCount 的功能

demo

@interface SemaphoreDemo()
@property (strong, nonatomic) dispatch_semaphore_t semaphore;
@property (strong, nonatomic) dispatch_semaphore_t ticketSemaphore;
@property (strong, nonatomic) dispatch_semaphore_t moneySemaphore;
@end

@implementation SemaphoreDemo

- (instancetype)init
{
    if (self = [super init]) {
        self.semaphore = dispatch_semaphore_create(5);
        self.ticketSemaphore = dispatch_semaphore_create(1);
        self.moneySemaphore = dispatch_semaphore_create(1);
    }
    return self;
}

- (void)__drawMoney
{
    dispatch_semaphore_wait(self.moneySemaphore, DISPATCH_TIME_FOREVER);
    
    [super __drawMoney];
    
    dispatch_semaphore_signal(self.moneySemaphore);
}

- (void)__saveMoney
{
    dispatch_semaphore_wait(self.moneySemaphore, DISPATCH_TIME_FOREVER);
    
    [super __saveMoney];
    
    dispatch_semaphore_signal(self.moneySemaphore);
}

- (void)__saleTicket
{
    dispatch_semaphore_wait(self.ticketSemaphore, DISPATCH_TIME_FOREVER);
    
    [super __saleTicket];
    
    dispatch_semaphore_signal(self.ticketSemaphore);
}

- (void)otherTest
{
    for (int i = 0; i < 20; i++) {
        [[[NSThread alloc] initWithTarget:self selector:@selector(test) object:nil] start];
    }
}

// 线程10、7、6、9、8
- (void)test
{
    // 如果信号量的值 > 0，就让信号量的值减1，然后继续往下执行代码
    // 如果信号量的值 <= 0，就会休眠等待，直到信号量的值变成>0，就让信号量的值减1，然后继续往下执行代码
    dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);
    
    sleep(2);
    NSLog(@"test - %@", [NSThread currentThread]);
    
    // 让信号量的值+1
    dispatch_semaphore_signal(self.semaphore);
}

@end

6.dispatch_queue(DISPATCH_QUEUE_SERIAL)

image.png

demo

@interface SerialQueueDemo()
@property (strong, nonatomic) dispatch_queue_t ticketQueue;
@property (strong, nonatomic) dispatch_queue_t moneyQueue;
@end

@implementation SerialQueueDemo

- (instancetype)init
{
    if (self = [super init]) {
        self.ticketQueue = dispatch_queue_create("ticketQueue", DISPATCH_QUEUE_SERIAL);
        self.moneyQueue = dispatch_queue_create("moneyQueue", DISPATCH_QUEUE_SERIAL);
    }
    return self;
}

- (void)__drawMoney
{
    dispatch_sync(self.moneyQueue, ^{
        [super __drawMoney];
    });
}

- (void)__saveMoney
{
    dispatch_sync(self.moneyQueue, ^{
        [super __saveMoney];
    });
}

- (void)__saleTicket
{
    dispatch_sync(self.ticketQueue, ^{
        [super __saleTicket];
    });
}

@end

使用技巧

#define SemaphoreBegin \
static dispatch_semaphore_t semaphore; \
static dispatch_once_t onceToken; \
dispatch_once(&onceToken, ^{ \
    semaphore = dispatch_semaphore_create(1); \
}); \
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

#define SemaphoreEnd \
dispatch_semaphore_signal(semaphore);

- (void)test1
{
    SemaphoreBegin;
    
    // .....
    
    SemaphoreEnd;
}

7.NSLock & NSRecursiveLock

NSLock 是对普通 mutex 锁的封装（互斥锁）

image.png

demo

- (void)testNSLock {
    NSLock *lock = [[NSLock alloc] init];
    [lock lock];
    // 需要锁定的代码
    [lock unlock];
}

8.NSCondition

image.png

demo

- (instancetype)init
{
    if (self = [super init]) {
        self.condition = [[NSCondition alloc] init];
        self.data = [NSMutableArray array];
    }
    return self;
}

- (void)otherTest
{
    [[[NSThread alloc] initWithTarget:self selector:@selector(__remove) object:nil] start];
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(__add) object:nil] start];
}

// 生产者-消费者模式

// 线程1
// 删除数组中的元素
- (void)__remove
{
    [self.condition lock];
    NSLog(@"__remove - begin");
    
    if (self.data.count == 0) {
        // 等待
        [self.condition wait];
    }
    
    [self.data removeLastObject];
    NSLog(@"删除了元素");
    
    [self.condition unlock];
}

// 线程2
// 往数组中添加元素
- (void)__add
{
    [self.condition lock];
    
    sleep(1);
    
    [self.data addObject:@"Test"];
    NSLog(@"添加了元素");
    // 信号
    [self.condition signal];
    
    // 广播
//    [self.condition broadcast];
    [self.condition unlock];
    
}

9.NSConditionLock

image.png

initWithCondition:(NSInteger)condition

• 初始化，并且设置条件锁内部存储的条件为 condition
• 如果直接 alloc init 创建，默认初始条件值为 0

lockWhenCondition:(NSInteger)condition 含义

• 当条件锁内部存储的条件是 condition 时才可以加锁

unlockWithCondition:(NSInteger)condition

• 解锁，同时设置内部存储的条件为2

lock

• 直接加锁，不去关心 condition

demo

@interface NSConditionLockDemo()
@property (strong, nonatomic) NSConditionLock *conditionLock;
@end

@implementation NSConditionLockDemo

- (instancetype)init
{
    if (self = [super init]) {
        self.conditionLock = [[NSConditionLock alloc] initWithCondition:1];
    }
    return self;
}

- (void)otherTest
{
    [[[NSThread alloc] initWithTarget:self selector:@selector(__one) object:nil] start];
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(__two) object:nil] start];
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(__three) object:nil] start];
}

- (void)__one
{
    [self.conditionLock lock];
    
    NSLog(@"__one");
    sleep(1);
    
    [self.conditionLock unlockWithCondition:2];
}

- (void)__two
{
    [self.conditionLock lockWhenCondition:2];
    
    NSLog(@"__two");
    sleep(1);
    
    [self.conditionLock unlockWithCondition:3];
}

- (void)__three
{
    [self.conditionLock lockWhenCondition:3];
    
    NSLog(@"__three");
    
    [self.conditionLock unlock];
}

@end

适用场景：处理多个线程间的依赖问题，实现线程间任务按指定顺序执行。

10.@synchronized

image.png

互斥锁：使用互斥锁，在同一个时间，只允许一条线程执行锁中的代码。因为互斥锁的代价非常昂贵，所以锁定的代码范围应该尽可能小，只要锁住资源读写部分的代码即可。使用互斥锁也会影响并发的目的。

@synchronized(锁对象) { 
    // 需要锁定的代码  
}

11.atomic

image.png

OC在定义属性时有nonatomic和atomic两种选择。 atomic：原子属性，为setter方法加锁（默认就是atomic） nonatomic：非原子属性，不会为setter方法加锁。 atomic加锁原理：

 @property (assign, atomic) int age;
 - (void)setAge:(int)age
 { 
     @synchronized(self) { 
        _age = age;
     }
 }

• atomic：线程安全，需要消耗大量的资源
• nonatomic：非线程安全，适合内存小的移动设备

iOS开发的建议:
（1）所有属性都声明为nonatomic
（2）尽量避免多线程抢夺同一块资源
（3）尽量将加锁、资源抢夺的业务逻辑交给服务器端处理，减小移动客户端的压力

多余容器对象（NSMutableArray等）进行 add/remove 操作不是线程安全的。

四、锁的性能比较

image.png

推荐使用 dispatch_semaphore 和 pthread_mutex

五、自旋锁与互斥锁比较

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

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

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

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

六、读写安全（读写锁）

1.iOS中的读写安全方案

思考如何实现以下场景

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

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

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

2.pthread_rwlock

image.png

demo

@interface ViewController ()
@property (assign, nonatomic) pthread_rwlock_t lock;
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 初始化锁
    pthread_rwlock_init(&_lock, NULL);
    
    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

3.dispatch_barrier_async

image.png

在 dispatch_barrier_async 执行任务时，绝对不允许有其他任务在执行。

image.png

面试题

1.你理解的多线程？

2.iOS的多线程方案有哪几种？你更倾向于哪一种？

3.你在项目中用过 GCD 吗？

4.GCD 的队列类型

5.说一下 OperationQueue 和 GCD 的区别，以及各自的优势

6.线程安全的处理手段有哪些？

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

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

8.如下

image.png