什么是GCD
GCD(Grand Central Dispatch)是异步执行任务的技术之一，一般将应用程序中记述的线程管理用的代码在系统级实现，开发者只需要定义想执行的任务，并把任务追加到适当的分发队列(Dispatch Queue)中，GCD就能生成必要的线程并计划执行任务。
GCD的优点
- GCD语法简单，使用Block回调，代码集中易懂，简化了多线程编程
- 因为线程管理是作为系统的一部分实现的，因此可以统一管理，也可执行任务，比之前的线程效率高（系统级线程管理）
GCD常见的API及其用法
- Dispatch Queue
如名称所示，是执行处理的等待队列，Dispatch Queue把编程人员定义的想要执行的处理按照追加的顺序（FIFO，First-In-First-Out）执行处理。
Dispatch Queue有两种，一种是等待现在执行中处理的Serial Dispatch Queue u（串行队列），另一种是不等待现在执行的Concurrent Dispatch Queue（并行队列），以下展示两种队列的区别
- (void) testDispatchQueue {
// 串行队列
dispatch_queue_t queue = dispatch_queue_create("com.lemon.dipatch", DISPATCH_QUEUE_SERIAL);
// 并行队列
// dispatch_queue_t queue = dispatch_queue_create("com.lemon.dispatch", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
sleep(2);
NSLog(@"1");
});
dispatch_async(queue, ^{
NSLog(@"2");
});
dispatch_async(queue, ^{
NSLog(@"3");
});
dispatch_async(queue, ^{
NSLog(@"4");
});
dispatch_async(queue, ^{
NSLog(@"5");
});
}
// 串行队列执行结果：
2019-01-01 14:53:28.483368+0800 TestBlock[68148:6421055] 1
2019-01-01 14:53:28.483502+0800 TestBlock[68148:6421055] 2
2019-01-01 14:53:28.483585+0800 TestBlock[68148:6421055] 3
2019-01-01 14:53:28.483664+0800 TestBlock[68148:6421055] 4
2019-01-01 14:53:28.483747+0800 TestBlock[68148:6421055] 5
// 并行队列执行结果：
2019-01-01 15:03:18.513884+0800 TestBlock[68263:6434398] 3
2019-01-01 15:03:18.513883+0800 TestBlock[68263:6434400] 2
2019-01-01 15:03:18.513896+0800 TestBlock[68263:6434396] 4
2019-01-01 15:03:18.513912+0800 TestBlock[68263:6434397] 5
2019-01-01 15:03:20.516357+0800 TestBlock[68263:6434399] 1
由以上结果可以看出，串行队列是按照顺序执行的，要等到现在的执行完成之后才能执行下一个，而并行队列是不用等待现在的执行处理结束，所以不管闪一个任务有没有结束，都开始执行下一个，但是并行处理的数量取决于当前系统的状态，当前的系统状态指的是iOS和OS X基于Dispatch Queue的处理数、CPU的核数及CPU负荷等。
- dispatch_queue_create
通过dispatch_queue_create可以创建Dispatch Queue，生成Serial Dispatch Queue的代码如下所示
// 第一个参数指定线程的名称，名字应该简单易懂，方便调试，
dispatch_queue_t queue = dispatch_queue_create("com.lemon.dipatch", NULL)
虽然Serial Dispatch Queue和Concurrent Dispatch Queue 受到系统资源的限制，但用dispatch_queue_create 可以生成任意多个Dispatch Queue，如果过多使用多线程，会消耗大量的内存，引起大量的上下文切换，降低系统的响应性能
使用结束后需要dispatch_release进行释放
-
Main Dispatch Queue/Global Dispatch Queue
Main Dispatch Queue是在主线程中执行的，属于串行队列，与UI相关的操作需要放在主线程执行。
Global Dispatch Queue是所用应用程序都能使用的并行队列，有高（High）、低（Low）、默认（Default）、后台（Background）四个优先级，
dispatch_queue_category.jpg
获取系统的Dispatch Queue的方法如下
// get main queue
dispatch_queue_t mainQueue = dispatch_get_main_queue();
// high priority global queue
dispatch_queue_t highGlobalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
// low priority global queue
dispatch_queue_t lowGlobalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
// default priority global queue
dispatch_queue_t defaultGlobalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// backgroud priority global queue
dispatch_queue_t backgroundQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
- dispatch_set_target_queue
dispatch_queue_create生成的Dispatch Queue，不管是并行队列还是串行队列，都是用与默认优先级Global Dispatch Queue相同执行优先级的线程，变更Dispatch Queue的优先级需要使用 dispatch_set_target_queue，举例如下：
// 当前队列
dispatch_queue_t serialQueue = dispatch_queue_create("com.lemon.dispatch", NULL);
// 目标队列
dispatch_queue_t backgroundQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
// 第一个参数为要变更执行优先级的队列 第二个参数为要使用的优先级队列
/*
Dispatch Queue 把当前队列上的任务，分发到指定的目标队列执行。可以把多个队列上的任务分发到目标队列去执行，在保证执行效率的前提下减少线程数量，如果一个队列设置了目标分发队列，系统不会分配线程，除非目标线程是全局队列
Dispatch sources 把对应的事件回调提交到目标队列去执行
Dispatch I/O channels 在目标队列上执行I/O操作
*/
dispatch_set_target_queue(serialQueue, backgroundQueue);
- dispatch_after
想在特定时间之后执行处理的操作，可以用dispath_after 实现
// 3秒之后将block追加到主线程
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
});
dispatch_after 函数并不是在指定的时间后执行处理，而是把处理追加到Dispatch Queue
- dispatch_group
在追加到Dispatch Queue中的多个处理全部结束后再执行后续处理，可以使用dispatch_group，示例如下
dispatch_group_t groupQueue = dispatch_group_create();
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_async(groupQueue, globalQueue, ^{
NSLog(@"execute job1");
});
dispatch_group_async(groupQueue, globalQueue, ^{
NSLog(@"execute job2");
});
dispatch_group_async(groupQueue, globalQueue, ^{
NSLog(@"execute job3");
});
dispatch_group_notify(groupQueue, dispatch_get_main_queue(), ^{
NSLog(@"execute the job on main thread");
});
执行结果如下：
2019-01-01 22:14:21.985148+0800 TestBlock[83010:6688021] execute job1
2019-01-01 22:14:21.985187+0800 TestBlock[83010:6688016] execute job3
2019-01-01 22:14:21.985263+0800 TestBlock[83010:6688022] execute job2
2019-11-01 22:14:22.001480+0800 TestBlock[83010:6687962] execute the job on main thread
因为Global Dispatch Queue是并行队列，所以追加处理的执行顺序不确定，但是在主线程执行的一定是在最后。
- dispatch_barrier_async
在访问数据库或文件时，使用并行队列会有数据竞争的问题，写入处理不能与其他写入处理和包含读取处理的其他处理并行执行，而读处理可以并行执行，dispatch_barrier_async 即可实现这个目的。
例如有如下需求，前三个任务需要读取数据，第四个任务需要写入数据，而后两个任务需要第四个任务写入之后的数据，
__block NSString *ballName = @"basketball";
dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_async(concurrentQueue, ^{
NSLog(@"execute the reading job1");
NSLog(@"The ball name is %@", ballName);
});
dispatch_async(concurrentQueue, ^{
NSLog(@"execute the reading job2");
NSLog(@"The ball name is %@", ballName);
});
dispatch_async(concurrentQueue, ^{
NSLog(@"execute the reading job3");
NSLog(@"The ball name is %@", ballName);
});
dispatch_barrier_async(concurrentQueue, ^{
NSLog(@"execute the writing job4");
ballName = @"football";
NSLog(@"The ball name is %@", ballName);
});
dispatch_async(concurrentQueue, ^{
NSLog(@"execute the reading job5");
NSLog(@"The ball name is %@", ballName);
});
dispatch_async(concurrentQueue, ^{
NSLog(@"execute the reading job6");
NSLog(@"The ball name is %@", ballName);
});
执行结果如下
2019-11-01 22:55:33.860155+0800 TestBlock[83120:6713619] execute the reading job1
2019-11-01 22:55:33.860173+0800 TestBlock[83120:6713620] execute the reading job2
2019-01-01 22:55:33.860192+0800 TestBlock[83120:6713617] execute the reading job3
2019-01-01 22:55:33.860211+0800 TestBlock[83120:6713618] execute the writing job4
2019-01-01 22:55:33.860287+0800 TestBlock[83120:6713619] The ball name is basketball
2019-01-01 22:55:33.860313+0800 TestBlock[83120:6713620] The ball name is basketball
2019-01-01 22:55:33.860329+0800 TestBlock[83120:6713617] The ball name is basketball
2019-01-01 22:55:33.860328+0800 TestBlock[83120:6713624] execute the reading job6
2019-01-01 22:55:33.860328+0800 TestBlock[83120:6713623] execute the reading job5
2019-01-01 22:55:33.860350+0800 TestBlock[83120:6713618] The ball name is football
2019-01-01 22:55:33.860679+0800 TestBlock[83120:6713624] The ball name is football
2019-01-01 22:55:33.861257+0800 TestBlock[83120:6713623] The ball name is football
- dispatch_sync
dispatch_sync 表示同步，也就是将指定的block同步追加到指定的Dispatch Queue中，在追加的block结束之前，dispatch_sync 函数会一直等待，比如在执行Main Dispatch Queue时，使用另外的Global Dispatch Queue进行处理，处理结束后立即使用得到的结果，这种情况下就需要使用dispatch_sync
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_sync(globalQueue, ^{
/*
得到结果之后的处理
*/
});
dispatch_sync使用简单，但是也容易出现死锁问题，比如以下代码
dispatch_queue_t mainQueue = dispatch_get_main_queue();
dispatch_sync(mainQueue, ^{
NSLog(@"execute on main thread");
});
- dispatch_apply
dispatch_apply是dispatch_sync和dispatch_group的关联API，该函数按照指定的次数将指定的block追加到指定的Dispatch Queue中，并等待全部处理执行结束。
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply(5, globalQueue, ^(size_t index) {
NSLog(@"%zu", index);
});
NSLog(@"dispatch_apply finished");
// 执行结果
2019-01-02 23:29:03.112894+0800 TestBlock[83409:6763722] 0
2019-01-02 23:29:03.113036+0800 TestBlock[83409:6763722] 1
2019-01-02 23:29:03.113074+0800 TestBlock[83409:6763786] 2
2019-01-02 23:29:03.113088+0800 TestBlock[83409:6763788] 3
2019-01-02 23:29:03.113095+0800 TestBlock[83409:6763785] 4
2019-01-02 23:29:03.113758+0800 TestBlock[83409:6763722] dispatch_apply finished
因为dispatch_apply与dispatch_sync都会等待处理执行结束，因此推荐在dispatch_async中非同步的使用dispatch_apply，示例如下
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_async(globalQueue, ^{
dispatch_apply(5, globalQueue, ^(size_t index) {
NSLog(@"%zu", index);
sleep(2);
});
NSLog(@"dispatch_apply finished");
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"update UI on main thread");
});
});
// 运行结果
2019-01-03 10:58:41.006055+0800 TestBlock[83587:6787137] 2
2019-01-03 10:58:41.006055+0800 TestBlock[83587:6787138] 1
2019-01-03 10:58:41.006055+0800 TestBlock[83587:6787139] 0
2019-01-03 10:58:41.006077+0800 TestBlock[83587:6787140] 3
2019-01-03 10:58:41.006099+0800 TestBlock[83587:6787143] 4
dispatch_apply finished
2019-11-03 10:58:45.012906+0800 TestBlock[83587:6787077] update UI on main thread
- dispatch_suspend和dispatch_resume
当追加大量的block到Dispatch Queue时，在追加处理的过程中，如果不希望执行已经追加的处理，调用dispatch_suspend 挂起当前队列即可，在需要恢复执行时，调用dispatch_resume 即可。 - dispatch semaphore
当并行处理数据时，会产生数据不一致的情况，例如在对NSMutableArray非线程安全的对象操作时，很容易产生问题，如下面例子所示
NSMutableArray *array =[[NSMutableArray alloc] init];
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
for (int i = 0; i < 1000; ++i) {
dispatch_async(globalQueue, ^{
[array addObject:[NSNumber numberWithInt:i]];
});
}
// 执行错误
TestBlock(83657,0x7000102a0000) malloc: *** error for object 0x7fbe02e0a9c0: pointer being freed was not allocated
TestBlock(83657,0x7000102a0000) malloc: *** set a breakpoint in malloc_error_break to debug
此时可以使用dispath_semaphore来控制，dispatch_semaphore采用计数信号，计数为0时等待，计数大于0时不等待，执行减1操作，用法如下
NSMutableArray *array =[[NSMutableArray alloc] init];
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 创建信号量，并设置初始计数为1，表示一次只能一个线程执行
dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
for (int i = 0; i < 1000; ++i) {
// 第一个线程时，计数为1，所以可以执行，并将semaphore的计数减1，此时计数为0，其他的线程只能等待
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
[array addObject:[NSNumber numberWithInt:i]];
// 执行结束时，将semaphore的计数加1，最先等待的线程此时就可以访问
dispatch_semaphore_signal(semaphore);
}
NSLog(@"The count of array is: %zu", array.count);
// 执行结果
2019-01-03 11:43:21.040081+0800 TestBlock[83707:6813328] The count of array is: 1000
此时可以正常用行，dispatch_semaphore 是比Serial Dispatch Queue 和dispatch_barrier_async更小粒度的控制。
- dispatch_once
dispatch_once是保证在应用程序中只运行一次指定处理的API，常用的用法如下
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
// the code execute only once
});
dispatch_once能保证在多线程的环境下也很安全，常用于单例模式。
总结
以上是GCD的概念和常用的API介绍，供大家参考，不足之处还请多多指教。
