探索底层原理，积累从点滴做起。大家好，我是Mars。

往期回顾

iOS底层原理探索—OC对象的本质
iOS底层原理探索—class的本质
iOS底层原理探索—KVO的本质
iOS底层原理探索— KVC的本质
iOS底层原理探索— Category的本质(一)
iOS底层原理探索— Category的本质(二)
iOS底层原理探索— 关联对象的本质
iOS底层原理探索— block的本质(一)
iOS底层原理探索— block的本质(二)
iOS底层原理探索— Runtime之isa的本质
iOS底层原理探索— Runtime之class的本质
iOS底层原理探索— Runtime之消息机制
iOS底层原理探索—RunLoop的本质
iOS底层原理探索—RunLoop的应用

前言

多线程是iOS开发中很重要的一个环节，无论是开发过程还是在面试环节中，多线程出现的频率都非常高。我们会通过几篇文章的探索，深入浅出的分析多线程技术。

多线程

在学习多线程之前，我们先熟悉几个概念。

一、概念

1、进程

当一个程序进入内存运行时，即变成一个进程。进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位。

进程的特点：

• 独立性：是系统独立存在的实体，拥有自己独立的资源，有自己私有的地址空间。在没有经过进程本身允许的情况下，一个用户的进程不可以直接访问其他进程的地址空间。
• 动态性：进程与程序的区别在于：程序只是一个静态的指令集合，而进程是一个正在系统中活动的指令集和，进程中加入了时间的概念。进程具有自己的生命周期和不同的状态，这些都是程序不具备的。
• 并发性：多个进程可以在单个处理器上并发执行，多个进程之间不会相互影响。

2、线程

线程是指程序在执行过程中，能够执行程序代码的一个执行单元，是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。进程中可以拥有多个线程，但是至少有一个线程。一个线程必须有一个父进程。

3、队列

队列，又称为伫列（queue），是先进先出（FIFO, First-In-First-Out）的线性表，在具体应用中通常用链表或者数组来实现。装载线程任务的队形结构。队列只允许在后端（称为rear）进行插入操作，在前端（称为front）进行删除操作。队列的操作方式和堆栈类似，唯一的区别在于队列只允许新数据在后端进行添加。

队列示意图.png

队列的类型

队列的类型决定了任务的执行方式（并发、串行），队列包括以下几种：

• 并发队列(Concurrent Dispatch Queue)： 线程执行可以同时一起进行执行,不需要上一个执行完，就能执行下一个的。
• 串行队列(Serial Dispatch Queue)： 线程执行只能依次逐一先后有序的执行,等待上一个执行完，再执行下一个。
• 主队列：绑定主线程，所有任务都在主线程中执行，有经过特殊处理的串行队列。
• 全局队列：系统提供的并发队列。

4、同步、异步

• 同步 sync： 只能在当前线程按先后顺序依次执行任务，不具备开启新线程的能力。
• 异步 async： 在新的线程中执行任务，具备开启新线程的能力。
  同步异步区别.png

二、多线程方案

常见的多线程方案.png
在实际开发过程中，GCD和NSOperation两种多线程方案的使用频率较高，GCD更接近底层，NSOperation基于GCD封装的，更加面向对象。

GCD和NSOperation区别

1、GCD仅仅支持FIFO队列，不支持异步操作之间的依赖关系设置。而NSOperation中的队列可以被重新设置优先级，从而实现不同操作的执行顺序调整。
2、NSOperation支持KVO，可以观察任务的执行状态。
3、GCD更接近底层，GCD在追求性能的底层操作来说，是速度最快的。
4、从异步操作之间的事务性，顺序行，依赖关系。GCD需要自己写更多的代码来实现，而NSOperation已经内建了这些支持
5、如果异步操作的过程需要更多的被交互和UI呈现出来，NSOperation更好。底层代码中，任务之间不太互相依赖，而需要更高的并发能力，GCD则更有优势

GCD

GCD的代码是开源的，大家可以通过下载源码，分析源码进一步了解GCD。
GCD中两个执行任务的函数：
同步执行任务：

//queue：队列   block：任务
dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);

异步执行任务：

//queue：队列   block：任务
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

我们通过代码来帮助了解同步执行和异步执行：

同步执行.png
我们在全局队列中同步执行任务1和任务2，通过打印可以看出，同步执行是按顺序执行任务，执行完任务1再执行任务2。并且打印当前线程，同步执行是在主线程中执行任务，没有开启新线程。
我们再来看一下异步执行：
异步执行.png
可以看出任务1和任务2交错执行，并非同步执行那样执行完任务1再执行任务2。而且通过线程编号可以看出，的确开启了新的线程。说明异步执行具备开启新线程的能力。

但是，如果在主队列中异步执行，是不会开启新线程的：

主队列中异步执行.png
由于主队列也是串行队列，虽然是异步执行，但是仍旧执行完任务1再执行任务2，并且是在主线程汇中执行，没有开启新的线程。

我们用一张表格来总结一下：

各种队列执行效果.png

总结

同步函数或者主队列：没有开启新线程、串行执行任务；
异步函数且非主队列：有开启新线程、执行方式取决与队列类型并发或串行

下面我们用几个例子来帮助我们理解：

1、下面代码的执行结果是什么

- (void)viewDidLoad {
    [super viewDidLoad];
    NSLog(@"任务1");
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_sync(queue, ^{
        NSLog(@"任务2");
    });
    NSLog(@"任务3");
}

答案是只会打印任务1，然后程序崩溃

首先分析一下代码：主线程执行完任务1后，在主队列dispatch_get_main_queue()中同步执行(dispatch_sync)任务2，然后执行任务3。

队列的特点是FIFO，主队列中已经存在任务viewDidLoad，往主队列加入任务2，就需要执行完viewDidLoad才能执行任务2。但是想要执行完viewDidLoad又必须先执行viewDidLoad内的任务2和任务3。这就造成了死锁。

死锁1.png

2、下面代码的执行结果是什么

- (void)viewDidLoad {
    [super viewDidLoad];
    NSLog(@"任务1");
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_async(queue, ^{
        NSLog(@"任务2");
    });
    NSLog(@"任务3");
}

答案是任务1，任务3，任务2

主线程执行任务1之后，需要异步(dispatch_async)执行任务2；而dispatch_async不要求立马在当前线程同步执行任务；所以主线程接着执行任务3，最后异步执行任务2。

不会死锁.png

3、下面代码的执行结果是什么

- (void)viewDidLoad {
    [super viewDidLoad];
    NSLog(@"任务1");
    dispatch_queue_t queue = dispatch_queue_create("myQueue", DISPATCH_QUEUE_SERIAL);
    dispatch_async(queue, ^{ 
        NSLog(@"任务2");
        dispatch_sync(queue, ^{ 
            NSLog(@"任务3");
        });
        NSLog(@"任务4");
    });
    NSLog(@"任务5");
}

答案是任务1，任务5，任务2，然后程序崩溃

主线程执行任务1之后，在串行队列DISPATCH_QUEUE_SERIAL中异步(dispatch_async)执行任务2，这时会开启子线程，不影响执行任务5。在子线程串行队列中，执行任务2，接着立刻同步(dispatch_sync)执行任务3。但是在串行队列中需要执行完任务4之后才能执行任务3，因此会产生死锁。

死锁2.png

4、下面代码的执行结果是什么

- (void)viewDidLoad {
    [super viewDidLoad];
    NSLog(@"任务1");
    dispatch_queue_t queue = dispatch_queue_create("myQueue", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t queue2 = dispatch_queue_create("myQueue2", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        NSLog(@"任务2");
        dispatch_sync(queue2, ^{ 
            NSLog(@"任务3");
        });
        NSLog(@"任务4");
    });
    NSLog(@"任务5");
}

答案是任务1，任务5，任务2，任务3，任务4

主线程执行任务1后，需要异步(dispatch_async)执行任务2；所以先执行主线程的任务5，然后执行任务2；接着需要在并发队列中同步(dispatch_sync)执行任务3；然后执行串行队列中的任务4。

不会产生死锁.png

5、下面代码的执行结果是什么

- (void)viewDidLoad {
    [super viewDidLoad];
    NSLog(@"任务1");
    dispatch_queue_t queue = dispatch_queue_create("myQueue", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t queue2 = dispatch_queue_create("myQueue2", DISPATCH_QUEUE_SERIAL);
    dispatch_async(queue, ^{
        NSLog(@"任务2");
        dispatch_sync(queue2, ^{
            NSLog(@"任务3");
        });
        NSLog(@"任务4");
    });
    NSLog(@"任务5");
}

答案是任务1，任务5，任务2，任务3，任务4

主线程执行任务1之后，需要异步(dispatch_async)执行串行队列中的任务2；所以先执行主线程的任务5，然后执行任务2；接着需要在另外一个串行队列中同步(dispatch_sync)执行任务3；然后回到第一个串行队列中执行任务4。

同样不会产生死锁.png

6、下面代码的执行结果是什么

- (void)viewDidLoad {
    [super viewDidLoad];
    NSLog(@"任务1");
    dispatch_queue_t queue = dispatch_queue_create("myQueue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        NSLog(@"任务2");
        dispatch_sync(queue, ^{
            NSLog(@"任务3");
        });
        NSLog(@"任务4");
    });
    NSLog(@"任务5");
}

答案是任务1，任务5，任务2，任务3，任务4

主线程执行任务1之后，需要异步(dispatch_async)执行任务2；所以先执行主线程的任务5，然后执行任务2；接着需要在并发队列中同步(dispatch_sync)执行任务3；然后执行并发队列中的任务4。

不会发生死锁.png

总结

使用同步函数dispatch_sync往当前串行队列中添加任务，会卡住当前的串行队列，即产生死锁。

更多技术知识请关注公众号
iOS进阶

iOS进阶.jpg