GCD 是基于 C 语言封装的多线程任务的 API，其隐藏线程技术，把任务的执行抽象到只需要操作队列上来，但了解其背后的线程还是很有必要的。
Dispatch Queue
串行队列(Serial Dispatch Queue)：队列中每次只有一个任务在执行，等待现在执行中处理的任务结束，才能进行下一个任务。在一个线程中完成。
串行队列的使用：
dispatch_queue_t serialDispatchQueue = dispatch_queue_create("com.queue.serial", DISPATCH_QUEUE_SERIAL);
dispatch_async(serialDispatchQueue, ^{
sleep(2);
NSLog(@"1");
});
dispatch_async(serialDispatchQueue, ^{
sleep(1);
NSLog(@"2");
});
dispatch_async(serialDispatchQueue, ^{
NSLog(@"3");
});
按顺序将 block 提交到串行队列的执行结果：
2016-08-28 18:00:14.760 GCDDemo[17019:1653504] 1
2016-08-28 18:00:15.764 GCDDemo[17019:1653504] 2
2016-08-28 18:00:15.765 GCDDemo[17019:1653504] 3
从结果可以看出，串行队列按照 FIFO 的原则，即使先提交的 Block sleep 时间比较长，还是先执行，等到前面提交的 Block 任务执行完成，才能继续执行下一个 Block。
当多个任务使用异步派发(dispatch_async)到串行队列时，系统会自动创建一个后台线程，本次执行的线程 ID 是 1653504。
并发队列(Concurrent Dispatch Queue)：队列中的任务并发执行，同一时间有多个任务被执行，不等待任务处理结束。
可能在多个线程中执行（并行）；也可能是运行在一个线程，将时间切片，执行上下文的切换来执行（并发）。
并发队列的使用：
dispatch_queue_t concurrentDispatchQueue = dispatch_queue_create("com.queue.concurrent", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(concurrentDispatchQueue, ^{
sleep(2);
NSLog(@"1");
});
dispatch_async(concurrentDispatchQueue, ^{
sleep(1);
NSLog(@"2");
});
dispatch_async(concurrentDispatchQueue, ^{
NSLog(@"3");
});
执行结果：
2016-08-28 18:17:12.400 GCDDemo[17131:1671062] 3
2016-08-28 18:17:13.402 GCDDemo[17131:1671068] 2
2016-08-28 18:17:14.405 GCDDemo[17131:1671067] 1
虽然三个 block 按顺序提交，但是执行结果不依赖提交的顺序，而是根据 block 执行所消耗的时间。
dispatch_async
异步提交队列的方式，使用 dispatch_async 提交一个 Block 到队列就会立即返回，任务会在之后由 GCD 决定执行。当需要在后台执行一个基于网络或 CPU 紧张的任务时就使用 dispatch_async ，这样就不会阻塞当前线程。
使用不同队列的情况：
- 自定义串行队列：当你想串行执行后台任务并追踪它时就是一个好选择。这消除了资源争用，因为你知道一次只有一个任务在执行。注意若你需要来自某个方法的数据，你必须内联另一个 Block 来找回它或考虑使用 dispatch_sync。
- 主队列（串行）：这是在一个并发队列上完成任务后更新 UI 的共同选择。要这样做，你将在一个 Block 内部编写另一个 Block 。以及，如果你在主队列调用 dispatch_async 到主队列，你能确保这个新任务将在当前方法完成后的某个时间执行。
- 并发队列：这是在后台执行非 UI 工作的共同选择。
dispatch_sync
dispatch_sync 会在当前线程执行队列，并且阻塞当前线程中之后运行的代码，所以，同步线程非常有可能导致死锁现象。举一个死锁的例子，直接在主线程调用以下代码：
// 主线程区域
dispatch_sync(dispatch_get_main_queue(), ^{
NSLog(@"有没有同步主线程?");
});
根据FIFO（先进先出）的原则，Block 里面的代码应该在主线程此次Runloop 结束后执行，但是由于它是同步队列，所有它之后的代码，会等待 Block 执行完成后才能继续执行，进而又造成此次的 RunLoop 无法退出，二者相互等待，出现死锁。
我们再举一个比较特殊的例子：
dispatch_queue_t queue=dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_sync(queue, ^{sleep(1);NSLog(@"1");});
dispatch_sync(queue, ^{sleep(1);NSLog(@"2");});
dispatch_sync(queue, ^{sleep(1);NSLog(@"3");});
NSLog(@"4");
其打印结果为：
2016-08-28 18:44:20.564 GCDDemo[17277:1701467] 1
2016-08-28 18:44:21.566 GCDDemo[17277:1701467] 2
2016-08-28 18:44:22.566 GCDDemo[17277:1701467] 3
2016-08-28 18:44:22.566 GCDDemo[17277:1701467] 4
从线程编号中我们发现，同步方法没有去开新的线程，而是在当前线程中执行队列，会有人问，上文说 dispatch_get_global_queue 不是并发队列，并发队列不是应该会在开启多个线程吗？这个前提是用异步方法。GCD其实是弱化了线程的管理，强化了队列管理，这使我们理解变得比较形象。
使用不同队列的情况：：
- 自定义串行队列：在这个状况下要非常小心！如果你正运行在一个队列并调用 dispatch_sync 放在同一个队列，那你就百分百地创建了一个死锁。
- 主队列（串行）：同上面的理由一样，必须非常小心！这个状况同样有潜在的导致死锁的情况。
- 并发队列：这才是做同步工作的好选择，不论是通过调度障碍，或者需要等待一个任务完成才能执行进一步处理的情况。
dispatch_after
这个是最常用的方式，用来延迟执行的GCD方法，因为在主线程中我们不能用 sleep 来延迟方法的调用，所以用它是最合适的，我们做一个简单的例子：
NSLog(@"主线程");
NSTimeInterval delayInSeconds = 2.0;
dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, delayInSeconds * NSEC_PER_SEC);
dispatch_after(popTime, dispatch_get_main_queue(), ^{
NSLog(@"2秒后主线程执行");
});
2016-08-28 18:54:36.563 GCDDemo[17352:1712795] 主线程
2016-08-28 18:54:38.564 GCDDemo[17352:1712795] 2秒后主线程执行
我们看到他就是在主线程，延迟了2.001秒，这为什么不是绝对的两秒？是因为 Block 的提交是在主线程 RunLoop 迭代之后，如果RunLoop 执行周期比较长，等到2秒时间到时RunLoop还未退出，Block 就可能被延迟提交。
使用不同队列的情况：：
- 自定义串行队列：在一个自定义串行队列上使用 dispatch_after 要小心。你最好坚持使用主队列。
- 主队列（串行）：是使用 dispatch_after 的好选择；Xcode 提供了一个不错的自动完成模版。
- 并发队列：在并发队列上使用 dispatch_after 也要小心；你会这样做就比较罕见。还是在主队列做这些操作吧。
Main Dispatch Queue & Global Dispatch Queue
Main Queue 正如其名中含有 「Main」，是在主线程中执行的。因为主线程只有一个，所以 Main Dispatch Queue 只有一个，自然就是 Serial Dispatch Queue。
Global Dispatch Queue 是所有应用程序都能够使用的 Concurrent Dispatch Queue。没必要通过 dispatch_queue_create 来生成一个 Concurrent Dispatch Queue。
通常两个会结合在一起使用：
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"异步线程");
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"异步主线程");
});
});
dispatch_get_global_queue 存在优先级：
#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
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), ^{
NSLog(@"4");
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0), ^{
NSLog(@"3");
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"2");
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
NSLog(@"1");
});
结果以1、2、3、4 的顺序打印，然而这是并发队列，也不绝对的保证高优先的任务队列先执行完成。
dispatch_set_target_queue
dispatch_queue_create 函数生成的 Dispatch Queue 不管是 Serial Dispatch Queue 还是 Concurrent Dispatch Queue，都使用与默认优先级 Global Dispatch Queue 相同执行优先级的线程。而变更队列的优先级需要使用 dispatch_set_target_queue 函数。在后台执行动作处理的 Serial Dispatch Queue 的生成方式如下：
// 原串行队列
dispatch_queue_t mySerailDispatchQueue = dispatch_queue_create("com.serial.queue", DISPATCH_QUEUE_SERIAL);
// 目标优先级队列
dispatch_queue_t globalDispatchQueueBackground = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
// 更改优先级
dispatch_set_target_queue(mySerailDispatchQueue, globalDispatchQueueBackground);
dispatch_group_t
在追加到 Dispatch Queue 中的多个处理全部结束之后想执行处理结果，这种情况经常会出现。只使用一个 Serial Dispatch Queue 时，只要将想执行的处理全部追加到该 Serial Dispatch Queue 中之后追加结束处理，即可实现。但是在使用个 Concurrent Dispatch Queue 时，源代码就会变得颇为复杂。
如下是使用 dispatch_group_t 实现五个下载任务全部完成之后，通知到主线程的例子：
- (void)downloadWithCompletionHandler:(void (^)(NSError *error))completionBlock {
__block NSError *_error = nil;
dispatch_group_t downloadGroup = dispatch_group_create();
NSUInteger count = 5;
// 批量任务下载
for (NSInteger i = 0; i < count; i++) {
NSURL *url = [NSURL URLWithString:@"http://www.download.com"];
dispatch_group_enter(downloadGroup);
NSURLSessionDownloadTask *task = [[NSURLSession sharedSession] downloadTaskWithURL:url completionHandler:^(NSURL * _Nullable location, NSURLResponse * _Nullable response, NSError * _Nullable error) {
if (error) {
_error = error;
}
dispatch_group_leave(downloadGroup);
}];
[task resume];
}
dispatch_group_notify(downloadGroup, dispatch_get_main_queue(), ^{
if (completionBlock) {
completionBlock(_error);
}
});
}
dispatch_group_enter 手动通知 Dispatch Group 任务已经开始。你必须保证 dispatch_group_enter 和 dispatch_group_leave 成对出现，否则可能会遇到诡异的崩溃问题。
dispatch_group_notify 会在 dispatch_group_enter 和 dispatch_group_leave 调用次数相等的时候触发 Block 的执行。
dispatch_barrier_async
此方法的作用是在并发队列中，完成在它之前提交到队列中的任务后打断，单独执行其block，并在执行完成之后才能继续执行在他之后提交到队列中的任务：
dispatch_queue_t concurrentDispatchQueue=dispatch_queue_create("com.test.queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(concurrentDispatchQueue, ^{NSLog(@"0");});
dispatch_async(concurrentDispatchQueue, ^{NSLog(@"1");});
dispatch_async(concurrentDispatchQueue, ^{NSLog(@"2");});
dispatch_async(concurrentDispatchQueue, ^{NSLog(@"3");});
dispatch_barrier_async(concurrentDispatchQueue, ^{sleep(1); NSLog(@"4");});
dispatch_async(concurrentDispatchQueue, ^{NSLog(@"5");});
dispatch_async(concurrentDispatchQueue, ^{NSLog(@"6");});
dispatch_async(concurrentDispatchQueue, ^{NSLog(@"7");});
dispatch_async(concurrentDispatchQueue, ^{NSLog(@"8");});
2016-03-07 14:45:32.410 GCD[10079:169655] 1
2016-03-07 14:45:32.410 GCD[10079:169658] 2
2016-03-07 14:45:32.410 GCD[10079:169656] 0
2016-03-07 14:45:32.410 GCD[10079:169661] 3
2016-03-07 14:45:33.414 GCD[10079:169661] 4
2016-03-07 14:45:33.415 GCD[10079:169661] 5
2016-03-07 14:45:33.415 GCD[10079:169658] 6
2016-03-07 14:45:33.415 GCD[10079:169655] 8
2016-03-07 14:45:33.415 GCD[10079:169662] 7
可以看出4之后的任务是在 sleep 之后才执行的。其实现像一个线程锁，在并发状态下执行读取操作，而在写的时候，使用 dispatch_barrier_async 锁住对象，保证数据安全。
dispatch_apply
dispatch_apply 函数是 dispach_asyn 函数和 Dispatch Group 的关联 API。该函数指定的次数将指定的 Block 追加到指定的 Dispatch Queue 中，并等待全部处理执行结束。
NSArray *array=[[NSArray alloc]initWithObjects:@"0",@"1",@"2",@"3",@"4",@"5",@"6", nil];
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply([array count], queue, ^(size_t index) {
NSLog(@"%zu=%@",index,[array objectAtIndex:index]);
});
NSLog(@"阻塞");
执行结果：
2016-03-07 17:36:50.726 GCD[14318:291701] 1=1
2016-03-07 17:36:50.726 GCD[14318:291705] 0=0
2016-03-07 17:36:50.726 GCD[14318:291783] 3=3
2016-03-07 17:36:50.726 GCD[14318:291782] 2=2
2016-03-07 17:36:50.726 GCD[14318:291784] 5=5
2016-03-07 17:36:50.726 GCD[14318:291627] 4=4
2016-03-07 17:36:50.726 GCD[14318:291785] 6=6
2016-03-07 17:36:50.727 GCD[14318:291627] 阻塞
可以发现在遍历数据完成之前，线程被阻塞，即使第二个参数派发的队列会全局队列，所以建议使用 dispatch_asyn 将该函数提交到 Global Dispatch Queue 中执行。
使用不同队列的情况：
- 自定义串行队列：串行队列会完全抵消 dispatch_apply 的功能；你还不如直接使用普通的 for 循环。
- 主队列（串行）：与上面一样，在串行队列上不适合使用 dispatch_apply 。还是用普通的 for 循环吧。
- 并发队列：对于并发循环来说是很好选择，特别是当你需要追踪任务的进度时。
dispatch_suspend/dispatch_resume
队列的挂起和恢复：
dispatch_queue_t concurrentDispatchQueue=dispatch_queue_create("com.test.queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(concurrentDispatchQueue, ^{
for (int i=0; i<100; i++) {
NSLog(@"%i",i);
if (i==50) {
NSLog(@"-----------------------------------");
dispatch_suspend(concurrentDispatchQueue);
sleep(3);
dispatch_async(dispatch_get_main_queue(), ^{
dispatch_resume(concurrentDispatchQueue);
});
}
}
});
我们甚至可以在不同的线程对这个队列进行挂起和恢复，因为 GCD 是对队列的管理。
dispatch_once
常用于单例的设计，也可用于应用程序整个生命周期中需要频繁调用而且开销比较大的函数中。举个例子：
CGSize YYScreenSize() {
static CGSize size;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
size = [UIScreen mainScreen].bounds.size;
if (size.height < size.width) {
CGFloat tmp = size.height;
size.height = size.width;
size.width = tmp;
}
});
return size;
}
对于 GCD 的的使用连抄带敲记录了一遍，希望能在特定的场景下信手拈来。
