1. GCD
1.1 简介
GCD (Grand Central Dispatch)，纯 C 语言。
- 会自动利用更多的
CPU内核 - 会
自动管理线程的生命周期(创建线程，调度任务，销毁线程) - 使用简单，将任务
添加进队列，并制定任务执行的函数
1.2 核心
在日常开发中，GCD 一般写成下面这种形式：
dispatch_async(dispatch_queue_create("com.test.queue", NULL), ^{
NSLog(@"GCD 基本使用");
});
我们将上面的代码拆分，方便更好的理解 GCD 的核心：任务 + 队列 + 函数：
// 创建任务
dispatch_block_t block = ^{
NSLog(@"GCD 基本使用");
};
// 创建串行队列
dispatch_queue_t queue = dispatch_queue_create("com.text.queue", NULL);
// 将任务添加到队列，并异步执行
dispatch_async(queue, block);
注意：任务使用
block封装，block 没有参数，也没有返回值
2. 函数与队列
2.1 同步和异步
在 GCD 中执行任务有两种：同步执行和异步执行，分别对应同步函数dispatch_sync和异步函数dispatch_async。
同步执行 dispatch_sync:
- 必须等当前语句执行完成，才会执行下一条语句
- 不会开启新线程，不具备开启新线程的能力
- 在当前线程中执行
block
异步执行 dispatch_async:
- 不用等待当前语句执行完毕，就可以执行下一条语句
- 具备开启新线程的能力，但并不一定开启新线程，这个与
队列类型有关
2.2 队列
多线程中所说的队列(Dispatch Queue)是指执行任务的等待队列，即用来存放任务的队列。
队列也是一种线性表，遵循先进先出(FIFO)原则。
在GCD 中，队列主要分为串行队列（Serial Dispatch Queue） 和并发队列（Concurrent Dispatch Queue）两种，如下图所示：
串行队列：
每次只有一个任务被执行，执行完之后才会执行下一个。
// 创建一个串行队列
dispatch_queue_t serialQueue1 = dispatch_queue_create("xxx", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t serialQueue2 = dispatch_queue_create("com.CJL.Queue", NULL);
并发队列：
一次可以并发执行多个任务，即开启多个线程，并同时执行任务。
// 并发队列的获取方法
dispatch_queue_t concurrentQueue = dispatch_queue_create("com.CJL.Queue", DISPATCH_QUEUE_CONCURRENT);
注意：并发队列的并发只有在
异步函数下才能体现，因为异步函数才能创建新的线程。
主队列和全局并发队列
在 GCD 中，针对这两种队列，分别提供了主队列(Main Dispatch Queue) 和全局并发队列(Global Dispatch Queue)：
- 主队列：也是串行队列
在主线程上调度任务的队列，依赖于主线程、主 Runloop，在 main 函数调用之前自动创建；
主队列的任务都是在主线程中执行，不会开辟新的线程；
如果当前主线程有任务执行，无论主队列中当前被添加了什么任务，都不会被调度；
使用dispatch_get_main_queue()获取主队列。
//主队列的获取方法
dispatch_queue_t mainQueue = dispatch_get_main_queue();
- 全局并发队列（
Global Dispatch Queue）：GCD提供的默认的并发队列
在使用多线程开发时，如果对队列没有特殊需求，在执行异步任务时，可以直接使用全局队列；
使用dispatch_get_global_queue获取全局并发队列。
//全局并发队列的获取方法
dispatch_queue_t globalQueue = dispatch_get_global_queue(0, 0);
第一个参数表示队列优先级，默认优先级为：DISPATCH_QUEUE_PRIORITY_DEFAULT=0，在iOS9之后，已经被服务质量（quality-of-service）取代；
第二个参数使用 0。
优先级如下：
//优先级从高到低（对应的服务质量）依次为
- DISPATCH_QUEUE_PRIORITY_HIGH -- QOS_CLASS_USER_INITIATED
- DISPATCH_QUEUE_PRIORITY_DEFAULT -- QOS_CLASS_DEFAULT
- DISPATCH_QUEUE_PRIORITY_LOW -- QOS_CLASS_UTILITY
- DISPATCH_QUEUE_PRIORITY_BACKGROUND -- QOS_CLASS_BACKGROUND
全局并发队列 + 主队列 配合使用
日常开发中，我们常用的配合使用如下：
//主队列 + 全局并发队列的日常使用
dispatch_async(dispatch_get_global_queue(0, 0), ^{
//执行耗时操作
dispatch_async(dispatch_get_main_queue(), ^{
//回到主线程进行UI操作
});
});
2.3 函数和队列的不同组合
不同的函数和不同的队列配合使用，产生的结果也是不同的。
2.3.1 串行队列 + 同步函数
任务按添加的顺序依次执行，在当前线程中执行，不会开辟新线程。
2.3.2 串行队列 + 异步函数
任务按添加的顺序依次执行，开辟了一个新线程。
2.3.3 并发队列 + 同步函数
任务按添加的顺序依次执行，在当前线程中执行，不会开辟新线程。
2.3.4 并发队列 + 异步函数
任务执行无顺序，会开辟新的线程。
2.3.5 主队列 + 同步函数
产生死锁，引发崩溃。
造成死锁的原因如下：
主队列有两个任务，NSLog 任务和同步 block，执行 NSLog 任务后，执行同步 Block，会将任务0 加入到主队列，主队列顺序为：NSLog 任务 - 同步 block - 任务 0，任务 0 的执行需要等待同步 block 执行完毕才会执行，而同步 block 的执行需要等待任务 0 执行完毕，所以就造成了任务互相等待的情况，即造成死锁崩溃。
2.3.6 主队列 + 异步函数
任务按添加的顺序依次执行，在主线程中执行，不会开辟新线程。
2.3.7 全局并发队列 + 异步函数 & 全局并发队列 + 异步函数
全局并发队列其实是系统为我们提供的并发队列，和上面并发队列 + 同步/异步函数执行的结果是一致的。
2.4 总结
| 函数\队列 | 串行队列 | 并发队列 | 主队列 | 全局并发队列 |
|---|---|---|---|---|
| 同步函数 | 顺序执行，不开辟线程 | 顺序执行，不开辟线程 | 死锁 | 顺序执行，不开辟线程 |
| 异步函数 | 顺序执行，开辟一个线程 | 乱序执行，可开辟多个线程 | 顺序执行，不开辟线程 | 乱序执行，可开辟多个线程 |
3. 示例
3.1 示例一 异步函数+并行队列
下面代码输出什么？
- (void)interview01{
//并行队列
dispatch_queue_t queue = dispatch_queue_create("com.CJL.Queue", DISPATCH_QUEUE_CONCURRENT);
NSLog(@"1");
// 耗时
dispatch_async(queue, ^{
NSLog(@"2");
dispatch_async(queue, ^{
NSLog(@"3");
});
NSLog(@"4");
});
NSLog(@"5");
}
输出结果为：1 5 2 4 3。
- 并发队列+异步执行，会开辟新的线程执行操作，不会影响主线程，开辟线程也需要一点时间，所以先输出 1 再输出 5.
- 执行异步任务，会先输出 2，之后开辟新的线程耗费时间，所以会先输出 4，最后输出 3.
如果将并行队列改为串行队列呢？
对结果仍然没有影响，也会开辟一个新的线程，耗费时间，顺序还是 1 5 2 4 3。
如果在任务 5 之前，sleep(2)呢？
执行的顺序为：1 2 4 3 5，因为开辟一个线程耗费的时间，相比于休眠 2s，更为少，所以异步 block 会先于任务 5 执行。
3.2 示例二 异步函数嵌套同步函数 + 并发队列
- (void)interview02{
//并发队列
dispatch_queue_t queue = dispatch_queue_create("com.CJL.Queue", DISPATCH_QUEUE_CONCURRENT);
NSLog(@"1");
//异步函数
dispatch_async(queue, ^{
NSLog(@"2");
//同步函数
dispatch_sync(queue, ^{
NSLog(@"3");
});
NSLog(@"4");
});
NSLog(@"5");
}
----------打印结果-----------
输出顺序为：1 5 2 3 4
分析：
- 1 和 5 的输出同上面一致，先输出 1 ，再输出 5，然后执行异步 block
- 在异步 block 中，首先执行
任务 2，然后走到同步 block，由于同步函数会阻塞主线程，所以任务 3会在任务 4之前完成，所以输出为 2 3 4 - 最终的结果为 1 5 2 3 4
3.3 示例三 异步函数嵌套同步函数 + 串行队列（即同步队列）
- (void)interview03{
// 同步队列
dispatch_queue_t queue = dispatch_queue_create("com.CJL.Queue", NULL);
NSLog(@"1");
// 异步函数
dispatch_async(queue, ^{
NSLog(@"2");
// 同步函数
dispatch_sync(queue, ^{
NSLog(@"3");
});
NSLog(@"4");
});
NSLog(@"5");
}
----------打印结果-----------
输出顺序为：1 5 2 死锁崩溃
分析：
- 先输出
1，之后异步 block，不会阻塞主线程，所以会先输出5，再执行异步 block - 之后执行到异步的
block中，输出2，接着执行同步block，同步 block 会阻塞线程，所以执行任务4需要等任务3完成，而任务3的执行，需要等待异步block完成，就造成了死锁现象。
3.4 示例四 异步函数 + 同步函数 + 并发队列
- (void)interview04{
//并发队列
dispatch_queue_t queue = dispatch_queue_create("com.CJL.Queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{ // 耗时
NSLog(@"1");
});
dispatch_async(queue, ^{
NSLog(@"2");
});
// 同步
dispatch_sync(queue, ^{
NSLog(@"3");
});
NSLog(@"0");
dispatch_async(queue, ^{
NSLog(@"7");
});
dispatch_async(queue, ^{
NSLog(@"8");
});
dispatch_async(queue, ^{
NSLog(@"9");
});
}
----------打印结果-----------
输出顺序为：（1 2 3 无序）0（7 8 9 无序），可以确定的是 0 一定在3之后，在789之前
分析：
-
任务1和任务2由于是异步函数+并发队列，会开启线程，所以没有固定顺序 -
任务7、任务8、任务9同理，会开启多个线程，所以没有固定顺序 -
任务3是同步函数+并发队列，同步函数会阻塞主线程，但是也只会阻塞0，所以，可以确定的是 0一定在3之后，在789之前。
