概念解释
1. 执行任务的函数：在GCD中，任务是通过 block来封装的，并且任务的block没有参数也没有返回值。
同步：你必须把我的代码执行完你再走，一定要执行完同步里的代码再执行下面的代码
void dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
异步：你先走执行我下面的代码，我找人、找线程去执行我里面的代码
void dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
2. GCD使用步骤：
第一步: 创建/获取 队列
第二步: 创建任务，确定要做的事情
第三步: 将任务添加到队列中
（1）GCD会自动将队列中的任务取出，放到对应的线程中执行
（2）任务的取出遵循队列的FIFO原则: 先进先出，后进后出
3. 队列
包括: 串行队列、并发队列、主队列、全局队列
1. 串行队列(Serial Dispatch Queue)
串行队列的特点:
以先进先出的方式，按顺序调度队列中的任务去执行，一次只能调度一个任务。
无论队列中所指定的执行任务的函数是同步还是异步，都必须等待前一个任务执行完毕，才可以调度后面的任务。
串行队列的创建:
(1) dispatch_queue_tqueue = dispatch_queue_create("itheima", DISPATCH_QUEUE_SERIAL);
(2) dispatch_queue_tqueue = dispatch_queue_create("itheima", NULL);
串行队列，同步执行：
开不开线程? 不开线程。
顺序执行还是乱序执行? 顺序执行。
串行队列，异步执行：
开不开线程? 只会开一条线程。
顺序执行还是乱序执行? 顺序执行。
2. 并发队列(Concurrent Dispatch Queue)
- 并发队列的特点:以先进先出的方式，并发(同时)调度队列中的任务去执行。
- 如果当前调度的任务是同步执行的，会等待当前任务执行完毕后，再调度后续的任务。
- 如果当前调度的任务是异步执行的，同时底层线程池有可用的线程资源，就不会等待当前任务，直接调度任务到新线程去执行。
并发队列的创建:
dispatch_queue_t q = dispatch_queue_create("itheima", DISPATCH_QUEUE_CONCURRENT);
并发队列，同步执行：
开不开线程? 不开线程。
顺序执行还是乱序执行? 顺序执行。
并发同步 和 串行同步的执行结果一模一样。
并发队列，异步执行：
开不开线程? 开多条新线程。
顺序执行还是乱序执行? 乱序执行。
3. 主队列：
- 遇到主队列，不管同步异步都要先执行完主线程里的代码再执行主队列里的代码
- dispatch_sync方法不能在主队列中调用，因为这会无限期的阻止线程并会导致你的应用死锁。所有通过GCD提交到主队列的任务必须是异步的。
- 只有当主线程空闲时, 主队列才会调度任务到主线程执行
- 主队列是系统提供的，无需自己创建，可以直接通过dispatch_get_main_queue()函数来获取。
- 主队列的特点：先执行完主线程上的代码，才会执行主队列中的任务
1、添加到主队列的任务只能由主线程来执行。
2、以先进先出的方式，只有当主线程的代码执行完毕后，主队列才会调度任务到主线程执行。
如下列代码执行打印123后再打印hello
- (void)demo1 {
for (int i = 0; i < 10; i++) {
NSLog(@"111");
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"hello %d %@",i,[NSThread currentThread]);
});
NSLog(@"222");
NSLog(@"333");
}
}
- 主队列，同步执行（死锁）主线程和主队列同步任务相互等待，造成死锁。
执行到同步主队列后，同步时主线程想让里面代码顺序执行下去（直接进去执行里面代码），而主队列要求执行完毕主线程代码再执行里面代码，导致谁都无法继续执行，导致死锁。
- (void)viewDidLoad {
[super viewDidLoad];
NSLog(@"begin");
for (int i = 0; i < 10; i++) { //死锁，一看同步就不分子线程了，一看主队列，就等着主线程执行完来执行里面代码
dispatch_sync(dispatch_get_main_queue(), ^{
NSLog(@"hello %d %@",i,[NSThread currentThread]);
}); }
NSLog(@"end");
}
- 解决死锁的问题，全局队列异步执行，里面嵌套主队列同步执行
当我们将主队列同步执行任务放到子线程去执行，就不会出现死锁。
由于将主队列同步放到了子线程中执行，主队列同步任务无法阻塞主线程执行代码，因此主线程可以将主线程上的代码执行完毕。当主线程执行完毕之后，就会执行主队列里面的任务。
先执行begin和end，再顺序执行全局队列异步执行（第二个线程里执行）
- (void)demo3 {
NSLog(@"begin");
dispatch_async(dispatch_get_global_queue(0, 0), ^{
for (int i = 0; i < 10; i++) {
dispatch_sync(dispatch_get_main_queue(), ^{
NSLog(@"hello %d %@",i,[NSThread currentThread]); }); }
});
NSLog(@"end");
}
主队列，异步执行
执行到异步主队列后，里面代码异步执行后释放（不创建新线程），主线程执行完毕后回来调用主队列中代码开不开线程? 主队列，就算是异步执行，也不会开线程。
顺序执行还是乱序执行? 顺序执行。
先把主线程上的代码执行完毕，才会执行添加到主队列里面的任务。
主队列和串行队列的区别
串行队列：必须等待一个任务执行完毕，才会调度下一个任务，顺序执行代码。
主队列：如果主线程上有代码执行，主队列就不调度任务，跳过主队列代码执行主线程代码，完毕后再执行主队列内代码。
4. 全局队列：
全局队列是系统提供的，无需自己创建，可以直接通过dispatch_get_global_queue(long identifier, unsigned long flags);函数来获取。
全局队列的工作特性跟并发队列一致。 实际上，全局队列就是系统为了方便程序员，专门提供的一种特殊的并发队列。
全局队列和并发队列的区别
全局队列：没有名称，无论ARC还是MRC都不需要考虑内存释放，日常开发，建议使用全局队列
并发队列：
（1）有名称，如果在MRC开发中，需要使用dispatch_release来释放相应的对象
（2）dispatch_barrier 必须使用自定义的并发队列
（3）开发第三方框架，建议使用并发队列第一个参数: identifier
iOS7.0，表示的是优先级:
DISPATCH_QUEUE_PRIORITY_HIGH = 2; 高优先级
DISPATCH_QUEUE_PRIORITY_DEFAULT = 0; 默认优先级
DISPATCH_QUEUE_PRIORITY_LOW = -2; 低优先级
DISPATCH_QUEUE_PRIORITY_BACKGROUND = INT16_MIN; 后台优先级
iOS8.0开始，推荐使用服务质量(QOS):
QOS_CLASS_USER_INTERACTIVE = 0x21; 用户交互
QOS_CLASS_USER_INITIATED = 0x19; 用户期望
QOS_CLASS_DEFAULT = 0x15; 默认
QOS_CLASS_UTILITY = 0x11; 实用工具
QOS_CLASS_BACKGROUND = 0x09; 后台
QOS_CLASS_UNSPECIFIED = 0x00; 未指定
通过对比可知: 第一个参数传入0，可以同时适配iOS7及iOS7以后的版本。
服务质量和优先级是一一对应的:
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
- 第二个参数: flags 为未来保留使用的，始终传入0。
方法：
- 获取系统队列
（1）获取主队列（一种串行队列） dispatch_queue_t 类型
dispatch_get_main_queue()
（2）获取全局队列（一种并发队列） dispatch_queue_t 类型
dispatch_get_global_queue(0, 0)
dispatch_queue_t dispatch_get_global_queue(long identifier, unsigned long flags);
- 自定义创建一个串行、并发队列
参数1：队列名
参数2：队列类型，串行还是并发队列
串行队列：DISPATCH_QUEUE_SERIAL 或 NULL
并发队列：DISPATCH_QUEUE_CONCURRENT
dispatch_queue_t dispatch_queue_create(const char *label, dispatch_queue_attr_t attr);
例子：创建一个串行队列
dispatch_queue_t queue = dispatch_queue_create("hm", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t queue = dispatch_queue_create("itheima", NULL);
- 创建任务
typedef void (^dispatch_block_t)(void);
例子：
dispatch_block_t task = ^{
NSLog(@"hello %@",[NSThread currentThread]);
};
- 将任务添加到队列（参数1：队列 参数2：任务）
- 同步函数，任务会在当前线程执行，因为同步函数不具备开新线程的能力。
同步：你必须把我的代码执行完你再走，一定要执行完同步里的代码再执行下面的代码
void dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
- 异步函数，任务会在子线程执行，因为异步函数具备开新线程的能力。
异步：你先走执行我下面的代码，我找人、找线程去执行我里面的代码
void dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
例子：将任务同步添加到队列和将任务异步添加到队列
（1）dispatch_sync(queue, task);
（2）dispatch_async(dispatch_get_global_queue(0, 0), ^{
NSLog(@"hello %@",[NSThread currentThread]);
});
- Barrier阻塞
void dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);
- 概念：会阻塞dispatch_barrier_async代码里的任务，让其它任务先执行完毕后再去执行里面的代码
- 用处：
（1）适合于大规模的 I/O 操作
（2）当访问数据库或文件的时候，更新数据的时候不能和其他更新或读取的操作在同一时间执行，可以使用调度组不过有点复杂。可以使用dispatch_barrier_async解决。 - 例子：执行结果十个图片下载完成先执行完毕，再执行十个保存图片
_queue = dispatch_queue_create("110", DISPATCH_QUEUE_CONCURRENT);
for (int i = 1; i<=10; i++) {
[self downloadImage:i];}
-(void)downloadImage:(int)index {
dispatch_async(_queue, ^{ //模拟下载图片
NSString *fileName = [NSString stringWithFormat:@"%02d.jpg",index % 10 + 1];
NSString *path = [[NSBundle mainBundle] pathForResource:fileName ofType:nil];
UIImage *img = [UIImage imageWithContentsOfFile:path];
//等待队列中所有的任务执行完成（十个图片下载完成任务），才会执行barrier中的代码
dispatch_barrier_async(_queue, ^{
[self.photoList addObject:img];
NSLog(@"保存图片 %@ %@",fileName,[NSThread currentThread]);
});
NSLog(@"图片下载完成 %@ %@",fileName,[NSThread currentThread]);
});
}
- 延时操作
void dispatch_after(dispatch_time_t when,
dispatch_queue_t queue,
dispatch_block_t block);
- 参数1：
dispatch_time_t when
多少纳秒之后执行
dispatch_time_t dispatch_time(dispatch_time_t when, int64_t delta);
#define DISPATCH_TIME_NOW (0ull)
#define DISPATCH_TIME_FOREVER (~0ull)
#define NSEC_PER_SEC 1000000000ull#define NSEC_PER_MSEC 1000000ull#define USEC_PER_SEC 1000000ull
#define NSEC_PER_USEC 1000ull
- 参数2：
dispatch_queue_t queue
任务添加到哪个队列 - 参数3：
dispatch_block_t block
要执行的任务
用法：延迟1秒后在主队列执行一个任务
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
});
- 一次性执行
- 注意：一次性执行是线程安全的，只在当前线程上一次性执行
- 步骤：
（1）创建一个静态的 dispatch_once_t 变量；
（2） dispatch_once(变量名, ^{
//一次性执行语句
}); - 原理：判断静态的全局变量的值，默认是0，执行完成后变为-1
dispatch_once内部会判断变量的值，如果是0才执行 - 用处：可以使用一次性执行创建单例对象，效率比互斥锁高
- 例子：
for (int i = 0; i<20000; i++) {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
NSLog(@"hello %@",[NSThread currentThread]); });
}
- 调度组
- 用处：有时候需要在多个异步任务都执行完成之后继续做某些事情，比如下载歌曲，等所有的歌曲都下载完毕之后再转到主线程提示用户
- 步骤：
（1）创建队列
（2）创建调度组
dispatch_group_t group = dispatch_group_create();
（3）监听调度组内队列任务是否执行完毕：把任务添加到队列中，队列添加到调度组中，队列任务执行完毕通知调度组
void dispatch_group_async(dispatch_group_t group,
dispatch_queue_t queue,
dispatch_block_t block);
（4）接收到调度组执行完毕的通知后，执行其它任务
void dispatch_group_notify(dispatch_group_t group,
dispatch_queue_t queue,
dispatch_block_t block);
例子：
//创建组
dispatch_group_t group = dispatch_group_create();
//队列
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
//下载第一首歌曲
dispatch_group_async(group, queue, ^{
NSLog(@"正在下载第一个歌曲");
});
//下载第二首歌曲
dispatch_group_async(group, queue, ^{
NSLog(@"正在下载第二个歌曲");
[NSThread sleepForTimeInterval:2.0];
});//下载第三首歌曲dispatch_group_async(group, queue, ^{ NSLog(@"正在下载第三个歌曲");
});
//当三个异步任务都执行完成，才执行dispatch_group_notify(group, dispatch_get_main_queue(), ^{ NSLog(@"over %@",[NSThread currentThread]);
});
