iOS GCD介绍
作者刘文涛
转载请注明出处
一、简单介绍
1.什么是GCD
Grand Central Dispatch是由苹果开发的一个多核编程的解决方案。iOS4.0+才能使用，是替代NSThread， NSOperation的高效和强大的技术。
苹果官方给出的解释：GCD是异步执行任务的技术之一。一般将应用程序中记述的线程管理代码在系统集中实现，开发者只需要定义想执行的任务并追加到适当的Dispatch Queue中，GCD就可以生成必要的线程并计划执行任务。
GCD是基于C语言的。
2.GCD的优点
它具有以下优点：
1.GCD可以将花费时间及其长的任务放到后台线程，可以改善应用的响应性能。
2.GCD提供一个易于使用的并发模型而不仅仅只是锁和线程，以帮助我们避开并发陷阱。
3.GCD具有在常见模式（例如单例）上用更高性能的底层语法优化你的代码的潜在能力等等。
我创建一个并行队列queue，并异步执行耗时操作，当耗时操作执行完成后，我拿到其中的资源回到主线程来更新相应的UI，在这个block代码块之外，主线程并不会被耗时任务所堵塞，可以流畅的处理其他的事情。
代码片段如下：
dispatch_queue_t queue = dispatch_queue_create("liuwentao", DISPATCH_QUEUE_CONCURRENT);
//用异步的方法执行任务
dispatch_async(queue, ^{
/**
放一些耗时的任务在此执行
*/
dispatch_async(dispatch_get_main_queue(), ^{
/**
耗时的任务完成，拿到资源，回到主线程，更新UI
注意：更新UI只能在主线程中
*/
});
});
二、任务和队列
GCD有两个核心的概念：
1.任务：执行什么操作
2.队列：用来存放任务
GCD的使用步骤：
1.定制任务
2.确定想做的事情
将任务添加到队列中，GCD会自动将队列中的任务取出，放到相应的线程中去执行。
提示：任务的取出遵循队列的FIFO（first in,first out）原则：先进先出，后进后出。
三、执行任务
1.GCD中有2个用来执行任务的函数
说明：把右边的参数（任务）提交给左边的参数（队列）进行执行。
（1）用同步的方法执行任务 dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
参数说明：
queue：队列
block：任务
（2）用异步的方法执行任务 dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
2.同步和异步的区别
同步：在当前线程中执行
异步：在另一条线程中执行
四、队列
1.队列的类型
GCD的队列可以分为2大类
（1）并发队列 （ DISPATCH_QUEUE_CONCURRENT ）
可以让多个任务并发执行（自动开启多个线程同时执行任务）并发功能只有在异步（dispatch——async）函数下才有效
（2）串行队列 （ DISPATCH_QUEUE_SERIAL ）
让任务一个接一个的执行 （一个任务执行完毕后，在执行下一个任务）
2.补充说明
同步和异步决定了要不要开启新的线程。
同步：在当前线程中执行任务，不具备开启新线程的能力
异步：在新的线程中执行任务，具备开启新线程的能力
并发和串行决定了任务的执行方式
并发：多个任务同时执行
串行：一个任务执行完毕后，在执行下一个任务
3.串行队列
GCD中获得串行有两种途径
（1）使用dispatch_queue_create函数创建串行队列
dispatch_queue_t queue = dispatch_queue_create(<#const char * _Nullable label#>, <#dispatch_queue_attr_t _Nullable attr#>) // 队列名称， 队列属性，一般用NULL即可
示例：
dispatch_queue_t queue = dispatch_queue_create("liuwentao", NULL);
（2）使用主队列
主队列是GCD自带的一种特殊的串行队列，放在主队列中的任务都会放到主线程中执行 使用dispatch_get_main_queue()获得主队列
示例：
dispatch_queue_t queue2 = dispatch_get_main_queue();
4.并发队列
GCD默认已经提供全局的并发队列，供整个应用使用，不需要手动创建
使用dispatch_get_global_queue函数获得全局的并发队列
示例：
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
说明：全局并发队列的优先级
#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 // 后台
5.各队列的执行效果
| 全局并发队列 | 手动创建串行队列 | 主队列 |
|---|---|---|
| 同步（sync） | 没有开启新线程，串行执行任务 | 没有开启新线程，串行执行任务 |
| 异步（async) | 开启新线程，并发执行任务 | 开启新线程，串行执行任务 |
五、示例代码
1.用异步函数往并发队列中添加任务
示例：
//1.获得全局的并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//2.添加任务到队列中，就可以执行任务
//异步函数：具备开启新线程的能力
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@",[NSThread currentThread]);
}
});
NSLog(@"主线程----%@",[NSThread mainThread]);
输出：
结论：
在并发队列+异步执行中可以看出，除了主线程同时又开启了三个子线程，并且任务交替着同时执行。并且任务不是马上执行的，而是将所有的任务添加到队列之后才开始异步执行的。
2.用异步函数往串行队列中添加任务
示例：
//打印主线程
NSLog(@"主线程-----%@",[NSThread mainThread]);
//1、创建串行队列
/**
第一个参数为串行队列的名称，是c语言的字符串
第二个参数为队列的属性，一般来说串行队列不需要赋值任何属性，所以通常传空值（NULL）
*/
dispatch_queue_t queue = dispatch_queue_create("liuwentao", NULL);
//2、添加任务到队列中执行
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@",[NSThread currentThread]);
}
});
输出：
结论：
在串行队列+异步执行可以看到，只开启了一条新线程，但是任务还是串行，所以任务是一个一个执行。并且是将所有任务添加到队列之后才开始同步执行。
3.用同步函数往并发队列中添加任务
示例：
//打印主线程
NSLog(@"主线程-----%@",[NSThread mainThread]);
//1.创建并发队列
dispatch_queue_t queue = dispatch_queue_create("liuwentao", DISPATCH_QUEUE_CONCURRENT);
//2.添加任务到队列中执行
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@",[NSThread currentThread]);
}
});
输出：
结论：
所有的任务都是在主线程中执行的，由于只有一个线程，所以任务只能一个一个执行，执行完一个任务，再执行下一个任务。并且并发队列是去了并发的功能。并且任务是添加到队列中马上执行的。
4.用同步函数往串行队列中添加任务
示例：
//打印主线程
NSLog(@"主线程-----%@",[NSThread mainThread]);
//1.创建并发队列
dispatch_queue_t queue = dispatch_queue_create("liuwentao", DISPATCH_QUEUE_SERIAL);
//2.添加任务到队列中执行
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@",[NSThread currentThread]);
}
});
输出：
结论：
所有的任务都是在主线程中执行的，并没有开启新的线程，并且按顺序一个一个执行。并且任务是添加到队列中马上执行的。
5.同步函数在主队列中执行
示例：
- (void)syncMain{
//打印主线程
NSLog(@"主线程-----%@",[NSThread mainThread]);
//获取主线程
dispatch_queue_t queue = dispatch_get_main_queue();
//2.添加任务到队列中执行
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@",[NSThread currentThread]);
}
});
}
输出：
这时候，我们发现在主线程中使用主队列+同步执行，任务不再执行了，这是为什么呢？
这是因为我们在主线程中执行这段代码。我们把任务放到了主队列中，也就是放到了主线程的队列中。而同步执行有个特点，就是对于任务是立马执行的。那么当我们把第一个任务放进主线程中他会立马执行。而syncMain执行到第一个任务的时候，又要等第一个任务执行完才能往下执行第二个任务和第三个任务。
那么现在的情况就是syncMain方法和第一的任务都在等对方执行完毕。这样大家互相等待，所以就卡住了，我们的任务执行不了了。
不在主线程中调用，而在其他线程中调用
dispatch_queue_t queue = dispatch_queue_create("liuwentao", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
[self syncMain];
});
`
- (void)syncMain{
NSLog(@"syncMain---begin");
//打印主线程
NSLog(@"主线程-----%@",[NSThread mainThread]);
//获取主线程
dispatch_queue_t queue = dispatch_get_main_queue();
//2.添加任务到队列中执行
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@",[NSThread currentThread]);
}
});
NSLog(@"syncMain---begin");
}
输出：
结论：
所有的任务都是在主线程中执行的，并没有开启新的线程。而且由于主队列是串行队列，所以按顺序一个一个的执行。同时我们还可以看到，所有的任务都是打印在syncConcurrent—begin和syncConcurrent—end之间，这说明任务是添加到队列中马上执行的。
6.异步函数在主队列中执行
示例：
- (void)asyncMain
{
NSLog(@"asyncMain---begin");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@",[NSThread currentThread]);
}
});
NSLog(@"asyncMain---end");
}
输出：
结论：
所有的任务都是在主线程中，虽然是异步执行，具备开启线程的能力，但是因为是主队列，所以所有任务都在主线程中，并且一个接一个执行。另一方面可以看出，所有任务是在打印的syncConcurrent—begin和syncConcurrent—end之后才开始执行的。说明任务不是马上执行，而是将所有任务添加到队列之后才开始同步执行。
6.GCD的其他方法
1.GCD的栅栏方法
我们有时候需要异步执行两组操作，而且第一组操作执行完之后，才能开始执行第二组操作。这样我们就需要一个相当于栅栏一样的一个方法将两组异步执行的操作组给分割起来，当然这里的操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async方法在两个操作组间形成栅栏。
- (void)barrier{
dispatch_queue_t queue = dispatch_queue_create("liuwentao", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@",[NSThread currentThread]);
}
});
dispatch_barrier_async(queue, ^{
NSLog(@"barrier-----%@",[NSThread currentThread]);
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"4------%@",[NSThread currentThread]);
}
});
}
输出：
结论：
可以看出在执行完栅栏前面的操作之后，才执行栅栏操作，最后在执行栅栏后面的操作。
2.GCD的延时执行方法
当我们需要延时执行一段代码时，就需要用到GCD的dispatch_after方法
示例：
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.9 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
//2 秒后执行这里的代码
NSLog(@"run-----");
});
3.GCD只执行一次
我们在创建单例或者整个程序运行过程中只执行一次的代码时，我们就用到了GCD的dispatch_once方法。使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次。
示例：
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
//只执行1次的代码（这里面默认是线程安全的）
});
4.GCD的快速迭代方法
通常我们会用for循环遍历，但是GCD给我们提供了快速迭代的方法dispatch_apply，使我们可以同时遍历。比如遍历0~5这6个数字，for循环是每次取出一个元素，逐个遍历。dispatch_apply可以同时遍历多个数字。
示例：
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply(6, queue, ^(size_t index) {
NSLog(@"%zd--------%@",index,[NSThread currentThread]);
});
输出：
结论：
从输出结果的时间可以看出，几乎是同时遍历出的。
5.GCD的队列组
有时候我们会有这样的需求：分别异步执行2个耗时操作，然后当2个耗时操作都执行完毕后在回到主线程执行操作。这时候我们可以用到GCD的队列组。
我们可以先把任务放到队列中，然后将队列放入队列组中。
调用队列组的dispatch_group_notify回到主线程执行操作。
示例：
//创建一个队列组
dispatch_group_t group = dispatch_group_create();
//添加任务到队列组中
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
//执行1个耗时的异步操作
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
//执行1个耗时的异步操作
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
//等前面的异步操作都执行完毕后，回到主线程中...
});
结语
以上就是我对GCD的基础知识和几种组合的理解，如果觉得我有哪里理解的错误欢迎留下你的评论。