GCD（Grand Central Dispatch） 介绍
GCD 属于系统级的线程管理，在 Dispatch queue 中执行任务时性能非常的高。GCD 和 operation queue 一样都是基于队列的并发编程 API，它们通过集中管理大家协同使用的线程池。GCD 这块已经开源（开源地址）。
队列
GCD 中的使用 FIFO 队列，用来保证先进来的任务先得到执行，这种队列称之为 dispatch queue。队列一共有两种类型，分别如下：
串行队列（Serial queue）：又叫
private dispatch queues，同时只执行一个任务（单独的block块），常用于同步访问特定的资源或数据。当创建多个serial queue时，虽然各自是同步，但serial queue之间是并发执行的。并行队列（Concurrent queue）：又叫
global dispatch queue，可以并发的执行多个任务（多个block块），但执行完成顺序是随机的。
全局队列
系统提供了 5 个不同全局队列，分别为：
- 主队列（
main queue） - 4个不同优先级的后台队列，它们的优先级分别为：
High Priority Queue，Default Priority Queue，Low Priority Queue，及优先级更低的Background Priority Queue（用于I/O）。
主队列（ main queue ）是主线程中的唯一队列，它是一个串行队列。获取主队列的函数如下：
dispatch_queue_t dispatch_get_main_queue(void)
全局队列都为并行的队列，获取方式如下：
-
object-c
dispatch_queue_t dispatch_get_global_queue(long identifier, unsigned long flags);此函数接收两个参数，第一个参数
identifier是队列的标识符，第二个参数flags标记保留供将来使用，始终对此参数指定0即可。identifier可以用下面的宏来指定不同优先级的队列。#define DISPATCH_QUEUE_PRIORITY_HIGH 2 #define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 #define DISPATCH_QUEUE_PRIORITY_LOW (-2) #define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN
- swift 3.0
在 swift 中对 GCD 相关 API 进行了封装，全部使用类来操作。swift 可以调用DispatchQueue的类方法获取：
// swift 3.0
public class func global(qos: DispatchQoS.QoSClass = default) -> DispatchQueue
这四种队列的优先级分别为：
- QOS_CLASS_USER_INTERACTIVE：
user interactive等级表示任务需要被立即执行，用来在响应事件之后更新 UI，来提供好的用户体验。这个等级最好保持小规模。 - QOS_CLASS_USER_INITIATED：
user initiated等级表示任务由 UI 发起异步执行。适用场景是需要及时结果同时又可以继续交互的时候。 - QOS_CLASS_UTILITY：
utility等级表示需要长时间运行的任务，伴有用户可见进度指示器。经常会用来做计算，I/O，网络，持续的数据填充等任务。这个任务节能。 - QOS_CLASS_BACKGROUND：
background等级表示用户不会察觉的任务，使用它来处理预加载，或者不需要用户交互和对时间不敏感的任务。
全局队列不是用户创建的，只能被获取，为了方便 GCD 的使用，apple 默认为我们提供的。
自定义队列
创建队列
除了系统提供的全局队列，也可以创建自定义队列。可以创建串行队列和并行队列两种类型的队列。创建自定义队列的方法如下：
- object-c
dispatch_queue_t dispatch_queue_create(const char *_Nullable label,
dispatch_queue_attr_t _Nullable attr);
此函数接收两个参数。第一个参数 label 为队列的标识符，遵循反向DNS命名习惯，方便描述，第二个参数 attr 为队列的属性。当 attr 为 NULL 或者 DISPATCH_QUEUE_SERIAL 时，可以创建串行队列，为 DISPATCH_QUEUE_CONCURRENT 时可以创建并行队列。
例如：
// 串行队列
dispatch_queue_create("com.fyf.serialqueue", DISPATCH_QUEUE_SERIAL)
// 并行队列
dispatch_queue_create("com.fyf.concurrentqueue", DISPATCH_QUEUE_CONCURRENT)
- switf
在swift中dispatch queue对应的类为DispatchQueue，可以使用下面方法进行初始化：
init(label: String, qos: DispatchQoS = default, attributes: DispatchQueue.Attributes = default, autoreleaseFrequency: DispatchQueue.AutoreleaseFrequency = default, target: DispatchQueue? = default)
设定队列优先级
- object-c
在 object-c 中有两种方式设置自定义队列的优先级，第一种为在创建队列时，用包含优先级的属性来指定队列的优先级。
dispatch_queue_attr_t dispatch_queue_attr_make_with_qos_class(dispatch_queue_attr_t _Nullable attr,
dispatch_qos_class_t qos_class, int relative_priority);
例如：
dispatch_queue_attr_t attr = dispatch_queue_attr_make_with_qos_class(DISPATCH_QUEUE_SERIAL, QOS_CLASS_UTILITY, -1);
dispatch_queue_t queue = dispatch_queue_create("com.fyf.qosqueue", attr);
第二种方法为参考其他队列的优先级，来设置自定义队列的优先级。
void dispatch_set_target_queue(dispatch_object_t object,
dispatch_queue_t _Nullable queue);
dispatch_set_target_queue 可以将参数 object 的优先级设置为 queue 的优先级。例如：
//需要设置优先级的 queue
dispatch_queue_t queue = dispatch_queue_create("com.fyf.settargetqueue", NULL);
//参考优先级 queue
dispatch_queue_t referQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
dispatch_set_target_queue(queue, referQueue); //设置 queue 和 referQueue 的优先级一样
dispatch_set_target_queue 也可以设置队列层级体系，比如让多个串行和并行队列在统一一个串行队列里串行执行，如下：
dispatch_queue_t serialQueue = dispatch_queue_create("com.fyf.serialqueue", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t firstQueue = dispatch_queue_create("com.fyf.firstqueue", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t secondQueue = dispatch_queue_create("com.fyf.secondqueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_set_target_queue(firstQueue, serialQueue);
dispatch_set_target_queue(secondQueue, serialQueue);
dispatch_async(serialQueue, ^{
NSLog(@"serialQueue 线程为：%@", [NSThread currentThread]);
});
dispatch_async(firstQueue, ^{
NSLog(@"开始第 1 个任务。%@", [NSThread currentThread]);
[NSThread sleepForTimeInterval:3.f];
NSLog(@"结束第 1 个任务。");
});
dispatch_async(secondQueue, ^{
NSLog(@"开始第 2 个任务。%@", [NSThread currentThread]);
[NSThread sleepForTimeInterval:2.f];
NSLog(@"结束第 2 个任务。");
});
dispatch_async(secondQueue, ^{
NSLog(@"开始第 3 个任务。%@", [NSThread currentThread]);
[NSThread sleepForTimeInterval:1.f];
NSLog(@"结束第 3 个任务。");
});
输出：
serialQueue 线程为：< NSThread: 0x608000079040>{number = 3, name = (null)}
开始第 1 个任务。< NSThread: 0x608000079040>{number = 3, name = (null)}
结束第 1 个任务。
开始第 2 个任务。< NSThread: 0x608000079040>{number = 3, name = (null)}
结束第 2 个任务。
开始第 3 个任务。< NSThread: 0x608000079040>{number = 3, name = (null)}
结束第 3 个任务。
由此可见，添加到 firstQueue 和 secondQueue 中的任务都在 serialQueue 队列中以串行的方式执行。
添加任务
获取到队列之后，我们就可以向队列中添加任务。添加任务的方法如下：
- object-c
void dispatch_sync(dispatch_queue_t queue, DISPATCH_NOESCAPE dispatch_block_t block);
void dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
dispatch_sync 和 dispatch_async 函数 需要两个参数，一个是队列 queue，一个是需要添加的任务 block。它们的共同点是 block 都会在指定的队列 queue 上执行，无论 queue 是并行队列还是串行队列；不同的是 dispatch_sync 会阻塞当前线程，直到 block 结束，而 dispatch_async 不会阻塞当前线程。在做比较耗时的任务时，比如读取网络数据，就需要使用 dispatch_async 将任务异步的添加到另一个线程中处理。
例如：
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_async(queue, ^{
// 完成任务
});
- swift 3.0
在 swift 中，使用DispatchQueue的下面的实例方法进行添加任务：
public func sync(execute workItem: DispatchWorkItem)
public func async(execute workItem: DispatchWorkItem)
例如：
let concurrentQueue = DispatchQueue.init(label: "concurrentQueue", qos: .default, attributes: .concurrent, autoreleaseFrequency: .inherit, target: nil);
concurrentQueue.async(execute: {
//
})
线程之间的切换
为了防止阻塞主线程，造成页面卡顿，影响交互，我们会将耗时的任务放到其他线程，等到任务结束时，再切换到主线程更新 UI，所以代码中经常会涉及到线程的切换。
例如：
- object-c
- (void)viewDidLoad {
[super viewDidLoad];
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_async(queue, ^{
// 完成耗时任务
dispatch_async(dispatch_get_main_queue(), ^{
// 在主线程中更新 UI
});
});
}
- swift 3.0
override func viewDidLoad() {
super.viewDidLoad()
// 将耗时的任务放到其他线程
DispatchQueue.global().async {
// 完成耗时任务
DispatchQueue.main.async {
// 返回到主线程刷新 UI
}
}
}
