【iOS】多线程

前言

这两天将iOS的多线程的使用都看了一遍，iOS的多线程方案有许多，本篇博客主要总结一下不同方案之间的区别以及面试一般会问到的问题

一、多线程的选择方案

二、GCD和NSOperation的比较

关系：
GCD面向底层C语言的API
NSOperation使用GCD进行封装的

对比

• GCD是苹果官方推荐的多线程方案，使用起来比较方便，更加轻量级
• GCD只支持FIFO的队列，NSOperation可以设置最大并发数控制串行并行以及通过添加依赖关系来调整执行顺序，这些都是GCD做不到的
• NSOpration甚至可以跨队列设置依赖关系，但是GCD只能通过设置串行队列，或者在队列内添加barrier任务才能控制执行顺序，较为复杂
• NSOperation支持KVO（面向对象）可以检测operation是否正在执行、是否结束、是否取消

- (void)viewDidLoad {
    [super viewDidLoad];
    
    self.operationQueue = [[NSOperationQueue alloc] init];
    
    [self.operationQueue addObserver:self
                          forKeyPath:@"operations"
                             options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld
                             context:NULL];
}

二、多线程相关概念

任务

就是执行的操作，比如GCD中的Block。
执行任务有两种方式：同步执行与异步执行

同步执行(sync):

• 同步添加任务到指定的队列中，在添加的任务结束之前线程会一直等待，无法执行其他操作
• 只能在当前线程中执行任务，不具备开启新线程的能力。

异步执行(async):

• 异步添加任务到指定的队列中，它不会做任何等待，添加后立即返回不会阻塞线程、可以继续执行任务.
• 可以在新的线程中执行任务，具备开启新线程的能力。

这样子来看可能比较抽象，我们用代码层面来理解就是：

进入dispatch_sync函数后程序不会立刻返回，因此会阻塞线程
而进入dispatch_async函数后程序会立刻返回，不会妨碍进行下一步操作

队列

这里的队列指执行任务的等待队列，即用来存放任务的队列。队列是一种特殊的线性表，采用 FIFO（先进先出）的原则。GCD 中有两种队列串行队列和并发队列。两者都符合 FIFO（先进先出）的原则。两者的主要区别是：执行顺序不同，以及开启线程数不同。

• 串行队列（Serial Dispatch Queue）：每次只有一个任务被执行。让任务一个接着一个地执行。（只开启一个线程，一个任务执行完毕后，再执行下一个任务）
• 并发队列（Concurrent Dispatch Queue）：可以让多个任务并发（同时）执行。（可以开启多个线程，并且同时执行任务）

三、死锁情况

主队列加同步任务

- (void)syncTaskWithMain {
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    dispatch_sync(mainQueue, ^{
        NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
        NSLog(@"任务2");
    });
}

// 在主线程中调用 syncTaskWithMain
- (void)viewDidLoad {
    [super viewDidLoad];
    [self syncTaskWithMain];
}

在上述代码中,我们在主线程的viewDidLoad方法中调用了asyncTaskWithMain函数,而在asyncTaskWithMain函数中,我们使用dispatch_sync向主队列提交了一个同步任务。
这种情况会导致死锁,原因如下:

1. 当[self syncTaskWithMain]被调用时,主线程进入了asyncTaskWithMain函数。
2. 在asyncTaskWithMain函数中,dispatch_sync函数会等待主队列空闲,然后在主队列中同步执行提交的任务。
3. 但是,由于主线程正在执行syncTaskWithMain函数,所以主队列被占用,无法空闲。
4. 因此,dispatch_sync函数会一直等待主队列空闲,而主线程也会一直被阻塞在syncTaskWithMain函数中,从而导致死锁。

为了避免死锁,我们应该在syncTaskWithMain函数中使用dispatch_async函数向主队列提交异步任务,或者在其他串行队列中使用dispatch_sync函数提交同步任务。

也就是二者相互等待造成死锁

四、任务队列组合

也就是只有当异步才会开辟新线程

主队列+异步

这里需要注意的一点是主队列+异步不会开辟新线程，这是由主队列的特性决定的

主队列+异步时既不会创建新的线程，也不会阻塞线程，我们来分析一下原因

主队列（Main Dispatch Queue）
主队列是一个特殊的串行队列，它在应用的主线程上执行任务。由于它是串行的，它一次只能执行一个任务。这意味着如果你在主队列上使用 dispatch_async 来提交一个任务，这个任务会被放到队列的末尾等待执行。

为什么不会创建新的线程
使用 dispatch_async 将任务提交到主队列时，这些任务不会创建新线程，因为：

• 主队列特性：
  主队列绑定于主线程，所有在主队列上提交的任务都必须在主线程上执行。这是由于主线程通常处理所有的 UI 更新和用户交互，所以系统保证主队列的任务在主线程上顺序执行。
• 任务调度：
  dispatch_async 函数只是将任务异步地放入队列中，它本身不关心任务的执行在哪个线程进行，任务的执行线程完全取决于队列的性质。由于主队列特性，即使使用 dispatch_async，任务仍然会在主线程上执行。

为什么不会导致阻塞
使用 dispatch_async 提交任务到主队列时，不会阻塞主线程，原因包括：

• 异步执行：
  dispatch_async 是异步执行的，这意味着它会立即返回，不会等待任务执行完成。因此，即使任务最终在主线程上执行，dispatch_async 本身也不会阻塞主线程。
• 执行时机：
  由于主队列是串行队列，提交到主队列的异步任务会在先前的任务完成后按顺序执行。如果主线程当前正在处理其他任务（如用户输入、动画等），那么主队列上的任务会等待直到主线程空闲。

也就是当主线程的所有的原先的任务都执行完后才回去执行添加到主队列中的异步任务

-(void)asyncTaskWithMain{
    NSLog(@"currentThread---%@",[NSThread currentThread]);
    dispatch_queue_t q = dispatch_get_main_queue();
    dispatch_async(q, ^{
        NSLog(@"1---%@",[NSThread currentThread]);
        NSLog(@"任务1");
    });
    NSLog(@"4");
}

// viewC
    [self asyncTaskWithMain];
    NSLog(@"等待");
    NSLog(@"等待");
    NSLog(@"等待");
    NSLog(@"等待");

输出：

并发队列+异步

同时如果是全局并发队列+异步，那么不会等待主队列任务执行完毕，两个线程会同时执行任务

    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_async(globalQueue, ^{
        NSLog(@"1---%@",[NSThread currentThread]);
        NSLog(@"任务1");
    });

输出：