本文的主要目的是理解不同队列与不同函数之间组合的情况
GCD简介
-
GCD全称是Grand Central Dispatch -
纯C语言，提供例如非常强大的函数
GCD优势
-
GCD是苹果公司为
多核的并行运算提出的解决方案 -
GCD会
自动利用更多的CPU内核（比如双核、四核） -
GCD会
自动管理线程的生命周期（创建线程、调度任务、销毁线程） -
程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码
【重点】用一句话总结GCD就是：将任务添加到队列，并指定任务执行的函数
GCD核心
在日常开发中，GCD一般写成下面这种形式
dispatch_async( dispatch_queue_create("com.CJL.Queue", NULL), ^{
NSLog(@"GCD基本使用");
});
将上述代码拆分，方便我们来理解GCD的核心 主要是由 任务 + 队列 + 函数 构成
//********GCD基础写法********
//创建任务
dispatch_block_t block = ^{
NSLog(@"hello GCD");
};
//创建串行队列
dispatch_queue_t queue = dispatch_queue_create("com.CJL.Queue", NULL);
//将任务添加到队列，并指定函数执行
dispatch_async(queue, block);
- 使用
dispatch_block_t创建任务 - 使用
dispatch_queue_t创建队列 - 将任务添加到队列，并指定执行任务的函数
dispatch_async
注意
这里的任务是指执行操作的意思，在使用dispatch_block_t创建任务时，主要有以下两点说明
-
任务使用
block封装 -
任务的block
没有参数也没有返回值
函数与队列
函数
在GCD中执行任务的方式有两种，同步执行和异步执行，分别对应 同步函数dispatch_sync 和 异步函数dispatch_async,两者对比如下
-
同步执行，对应同步函数
dispatch_sync-
必须等待当前语句执行完毕，才会执行下一条语句 -
不会开启线程，即不具备开启新线程的能力 -
在当前线程中执行block任务
-
-
异步执行，对应异步函数
dispatch_async-
不用等待当前语句执行完毕，就可以执行下一条语句
-
会
开启线程执行block任务，即具备开启新线程的能力（但并不一定开启新线程，这个与任务所指定的队列类型有关） -
异步 是 多线程 的代名词
-
所以，综上所述，两种执行方式的主要区别有两点：
-
是否等待队列的任务执行完毕 -
是否具备开启新线程的能力
队列
串行队列 和 并发队列
多线程中所说的队列（Dispatch Queue）是指执行任务的等待队列，即用来存放任务的队列。队列是一种特殊的线性表，遵循先进先出（FIFO）原则，即新任务总是被插入到队尾，而任务的读取从队首开始读取。每读取一个任务，则动队列中释放一个任务，如下图所示
image
在GCD中，队列主要分为串行队列（Serial Dispatch Queue） 和并发队列（Concurrent Dispatch Queue）两种，如下图所示
-
-
串行队列：每次只有一个任务被执行，等待上一个任务执行完毕再执行下一个，即只开启一个线程（通俗理解：同一时刻只调度一个任务执行）-
使用
dispatch_queue_create("xxx", DISPATCH_QUEUE_SERIAL);创建串行队列 -
其中的
DISPATCH_QUEUE_SERIAL也可以使用NULL表示，这两种均表示默认的串行队列
-
// 串行队列的获取方法
dispatch_queue_t serialQueue1 = dispatch_queue_create("com.CJL.Queue", NULL);
dispatch_queue_t serialQueue2 = dispatch_queue_create("com.CJL.Queue", DISPATCH_QUEUE_SERIAL);
-
并发队列：一次可以并发执行多个任务，即开启多个线程，并同时执行任务（通俗理解：同一时刻可以调度多个任务执行）-
使用
dispatch_queue_create("xxx", DISPATCH_QUEUE_CONCURRENT);创建并发队列 -
注意：并发队列的并发功能只有在
异步函数下才有效
-
// 并发队列的获取方法
dispatch_queue_t concurrentQueue = dispatch_queue_create("com.CJL.Queue", DISPATCH_QUEUE_CONCURRENT);
主队列 和 全局并发队列
在GCD中，针对这两种队列，分别提供了主队列（Main Dispatch Queue）和全局并发队列（Global Dispatch Queue）
-
主队列（Main Dispatch Queue）：GCD中提供的特殊的串行队列-
专门用来
在主线程上调度任务的串行队列，依赖于主线程、主Runloop，在main函数调用之前自动创建 -
不会开启线程
-
如果当前主线程正在有任务执行，那么无论主队列中当前被添加了什么任务，都不会被调度
-
使用
dispatch_get_main_queue()获得主队列 -
通常在返回
主线程 更新UI时使用
-
//主队列的获取方法
dispatch_queue_t mainQueue = dispatch_get_main_queue();
-
全局并发队列（Global Dispatch Queue）：GCD提供的默认的并发队列-
为了方便程序员的使用，苹果提供了全局队列
-
在使用多线程开发时，如果对队列没有特殊需求，
在执行异步任务时，可以直接使用全局队列 -
使用
dispatch_get_global_queue获取全局并发队列，最简单的是dispatch_get_global_queue(0, 0)-
第一个参数表示
队列优先级，默认优先级为DISPATCH_QUEUE_PRIORITY_DEFAULT=0，在ios9之后，已经被服务质量（quality-of-service）取代 -
第二个参数使用0
-
-
//全局并发队列的获取方法
dispatch_queue_t globalQueue = dispatch_get_global_queue(0, 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操作
});
});
函数与队列的不同组合
串行队列 + 同步函数
【任务按顺序执行】：任务一个接一个的在当前线程执行，不会开辟新线程
串行队列 + 异步函数
【任务按顺序执行】：任务一个接一个的执行，会开辟新线程
并发队列 + 同步函数
【任务按顺序执行】：任务一个接一个的执行，不开辟线程
并发队列 + 异步函数
【任务乱序执行】：任务执行无顺序，会开辟新线程
主队列 + 同步函数
【造成死锁】：任务相互等待，造成死锁
造成死锁的原因分析如下：
-
主队列有两个任务，顺序为：
NSLog任务 - 同步block -
执行NSLog任务后，执行同步Block，会将任务1（即i=1时）加入到主队列，主队列顺序为：
NSLog任务 - 同步block - 任务1 -
任务1的执行需要等待同步block执行完毕才会执行，而同步block的执行需要等待任务1执行完毕，所以就造成了任务互相等待的情况，即造成死锁崩溃
死锁现象
-
主线程因为你同步函数的原因等着先执行任务 -
主队列等着主线程的任务执行完毕再执行自己的任务 -
主队列和主线程相互等待会造成死锁
主队列 + 异步函数
【任务按顺序执行】：任务一个接一个的执行，不开辟线程
全局并发队列 + 同步函数
【任务按顺序执行】：任务一个接一个的执行，不开辟新线程
全局并发队列 + 异步函数
【任务乱序执行】：任务乱序执行，会开辟新线程
总结
| 函数\队列 | 串行队列 | 并发队列 | 主队列 | 全局并发队列 |
|---|---|---|---|---|
| 同步函数 | 顺序执行，不开辟线程 | 顺序执行，不开辟线程 | 死锁 | 顺序执行，不开辟线程 |
| 异步函数 | 顺序执行，开辟线程 | 乱序执行，开辟线程 | 顺序执行，不开辟线程 | 乱序执行，开辟线程 |
相关面试题解析
【面试题 - 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、异步block1、任务5，其中异步block1会比较耗费性能，任务1和任务5的任务复杂度是相同的，所以任务1和任务5优先于异步block1执行 -
在
异步block1中，任务队列为：任务2、异步block2、任务4，其中block2相对比较耗费性能，任务2和任务4是复杂度一样，所以任务2和任务4优先于block2执行 -
最后执行
block2中的任务3 -
在极端情况下，可能出现
任务2先于任务1和任务5执行，原因是出现了当前主线程卡顿或者延迟的情况
代码修改
-
【修改1】：将
并行队列改成串行队列，对结果没有任何影响，顺序仍然是1 5 2 4 3 -
【修改2】：在任务5之前，休眠2s，即
sleep(2)，执行的顺序为：1 2 4 3 5,原因是因为I/O的打印，相比于休眠2s，复杂度更简单，所以异步block1 会先于任务5执行。当然如果主队列堵塞，会出现其他的执行顺序
【面试题 - 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，由于同步函数会阻塞当前线程，所以任务4需要等待任务3执行完成后，才能执行，所以异步block中的执行顺序是：任务2 任务3 任务4 -
【面试题 - 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而言，复杂度更高，所以优先执行任务5，在执行异步block -
在
异步block中，先执行任务2，接下来是同步block，同步函数会阻塞线程，所以执行任务4需要等待任务3执行完成，而任务3的执行，需要等待同步block执行完成，相当于任务3等待任务4完成 -
所以就造成了
任务4等待任务3，任务3等待任务4，即互相等待的局面，就会造成死锁，这里有个重点是关键的堆栈 slow
image
修改
去掉任务4，执行顺序是什么？
- 还是会
死锁，因为任务3等待的是异步block执行完毕，而异步block等待任务3
【面试题 - 4 - 新浪】 异步函数 + 同步函数 + 并发队列
下面代码的执行顺序是什么？（答案是 AC）
A: 1230789
B: 1237890
C: 3120798
D: 2137890
- (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之前
以下是不同的执行顺序的打印
【面试题 - 5 - 美团】下面代码中，队列的类型有几种？
//串行队列 - Serial Dispatch Queue
dispatch_queue_t serialQueue = dispatch_queue_create("com.CJL.Queue", NULL);
//并发队列 - Concurrent Dispatch Queue
dispatch_queue_t concurrentQueue = dispatch_queue_create("com.CJL.Queue", DISPATCH_QUEUE_CONCURRENT);
//主队列 - Main Dispatch Queue
dispatch_queue_t mainQueue = dispatch_get_main_queue();
//全局并发队列 - Global Dispatch Queue
dispatch_queue_t globalQueue = dispatch_get_global_queue(0, 0);
队列总共有两种： 并发队列 和 串行队列
- 串行队列：serialQueue、mainQueue
- 并发队列：concurrentQueue、globalQueue
网友评论