简介：
GCD是对多线程、多核开发较完整的封装。在使用GCD的时候，系统会自动根据CPU使用情况进行调度，所以GCD是一个简单易用，但是效果很好的多线程多核开发工具。
概念
同步：在当前线程不开启新的线程,任务顺序执行，同步操作添加任务后等待任务执行
异步：在当前线程开启新的线程(主线程除外)，任务执行可以不按顺序执行（串行队列顺序执行，并发队列异步执行),异步操作添加任务后立即返回
串行：任务执行按照顺序
并发：任务执行可以异步执行（具体顺序结合对应的任务操作类型async/sync）
串行队列/并发队列
Dispatch Queue按照追加的顺序（先进先出FIFO，First-In-First-Out）执行处理。
- Queue(队列)：分为串行队列和并行队列，所谓的串行和并行是指任务的执行顺序。
串行队列上添加A、B、C、D四个任务，任务的执行顺序必然也是A、B、C、D的顺序。
并发队列上添加A、B、C、D四个任务，sync(同步)操作任务顺序执行；async(异步)操作任务异步执行。 -
Dispatch Queue队列几种创建方式
//获得主线程的dispatch队列
dispatch_queue_t queue = dispatch_get_main_queue();
//获得程序进程缺省产生的并发队列，可设定优先级来选择高、中、低三个优先级队列。
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//生成一个串行队列，队列中的block按照先进先出（FIFO）的顺序去执行，实际上为单线程执行
dispatch_queue_t queue = dispatch_queue_create("com.dispatch.serial", DISPATCH_QUEUE_SERIAL);
//生成一个并发执行队列，block被分发到多个线程去执行
dispatch_queue_t queue = dispatch_queue_create("com.dispatch.concurrent", DISPATCH_QUEUE_CONCURRENT);
同步、异步、串行、并发
同步异步代表任务添加的时候会不会立即返回，任务执行的时候会不会开辟新的线程。串行和并发代表任务执行的方式。
同步串行和并发，任务的执行方式是一样的。没有区别，因为没有开辟新的线程，所有的任务都在一条线程中执行。
异步串行和异步并发，任务执行的方式是有区别的，异步主队列不会开辟线程，但是任务依然是异步执行，主线程执行完当前线程的所有任务后，才会去执行异步添加的任务；异步串行会开辟一条新的线程，队列中所有任务按照添加的顺序一个一个执行；异步并发会开辟多条线程，至于具体开辟多少条线程，是由系统决定的，但是所有的任务好像就是同时执行的一样。
GCD-同步函数／异步函数
- sync(同步)函数
提交任务后等待任务执行完毕，会阻塞当前线程
dispatch_sync(queue, ^{
//block具体代码
});
同步执行block，函数不返回，一直等到block执行完毕。编译器会根据实际情况优化代码，
所以有时候你会发现block其实还在当前线程上执行，并没用产生新线程。
- async(异步)函数
提交任务后会立即返回，不会阻塞当前线程
dispatch_async(queue, ^{
//block具体代码
}); //异步执行block，函数立即返回
同步执行block，函数不返回，一直等到block执行完毕。编译器会根据实际情况优化代码，
所以有时候你会发现block其实还在当前线程上执行，并没用产生新线程。
- sync同步／async异步操作注意点
实际编程经验告诉我们，尽可能避免使用dispatch_sync，嵌套使用时还容易引起程序死锁。
串形队列的同步嵌套造成循环的任务等待，造成死锁
dispatch_sync(queue1, ^{
dispatch_sync(queue1, ^{
......
});
......
});
不妨思考下，为什么下面代码在主线程中执行会死锁：
dispatch_sync(dispatch_get_main_queue(), ^{
......
});
是否会死锁，实质是分析对应的代码操作是否存在相互等待的操作
特点是：同步操作内部嵌套/存在一个同步的操作，并且这两个同步操作所在的对列是同一个串行的队列，
并且这两个同步操作之间不存在异步操作嵌套（主线程默认就是一个就串行同步的队列）
那实际运用中，一般可以用dispatch这样来写，常见的网络请求数据多线程执行模型：
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
//子线程中开始网络请求数据
//更新数据模型
dispatch_sync(dispatch_get_main_queue(), ^{
//在主线程中更新UI代码
});
});
//程序的后台运行和UI更新代码紧凑，代码逻辑一目了然。
sync/async + queue(几种搭配)
-
sync(同步) +queue（主队列／自定义串行队列／并发队列）
sync+ 主队列
dispatch_sync(dispatch_get_main_queue(), ^{
//do something ...
});
//主线程被阻塞，任务不会被执行。。。
sync + 自定义串行队列
dispatch_queue_t serialQueue = dispatch_queue_create("com.dispatch.serial", DISPATCH_QUEUE_SERIAL);
for (NSInteger j=0 ; j<10; j++) {
dispatch_sync(serialQueue, ^{
//do something ...
});
}
//当前线程上顺序(串行)执行任务，不会创建新的线程,任务添加时刻便开始执行
sync + 并发队列
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_sync(globalQueue, ^{
// do something ...
});
//在当前线程中顺序（串行）执行，没有创建新的线程，任务添加时刻便开始执行
-
async(异步) +queue（主队列／自定义串行队列／并发队列）
async+ 主队列
dispatch_async(mainQueue, ^{
NSLog(@"%@",[NSThread currentThread]);
NSLog(@"1");
});
dispatch_async(mainQueue, ^{
NSLog(@"%@",[NSThread currentThread]);
NSLog(@"2");
});
dispatch_async(mainQueue, ^{
NSLog(@"%@",[NSThread currentThread]);
NSLog(@"3");
});
dispatch_async(mainQueue, ^{
NSLog(@"%@",[NSThread currentThread]);
NSLog(@"4");
});
dispatch_async(mainQueue, ^{
NSLog(@"%@",[NSThread currentThread]);
NSLog(@"5");
});
dispatch_async(mainQueue, ^{
NSLog(@"%@",[NSThread currentThread]);
NSLog(@"6");
});
NSLog(@"end");
1.异步任务在主队列上，没有开辟新的线程，任务依然是保持队形的。
2.是异步的但是又没有产生新的线程，这个和之前的异步不太一样，需要留意。
3.dispatch_async方法，往主队列添加了一个异步任务，此时并不阻塞主线程，
主线程立刻返回执行后面的任务。主线程当前的任务完成了，然后从主队列取出下一个任务（刚刚添加的异步任务）来执行
输出
async + 自定义串行队列
dispatch_async(serialQueue, ^{
NSLog(@"%@",[NSThread currentThread]);
NSLog(@"1");
});
dispatch_async(serialQueue, ^{
NSLog(@"%@",[NSThread currentThread]);
NSLog(@"2");
});
dispatch_async(serialQueue, ^{
NSLog(@"%@",[NSThread currentThread]);
NSLog(@"3");
});
dispatch_async(serialQueue, ^{
NSLog(@"%@",[NSThread currentThread]);
NSLog(@"4");
});
dispatch_async(serialQueue, ^{
NSLog(@"%@",[NSThread currentThread]);
NSLog(@"5");
});
dispatch_async(serialQueue, ^{
NSLog(@"%@",[NSThread currentThread]);
NSLog(@"6");
});
//开辟一个新的线程，线程中任务顺序(串行)执行
输出
async + 并发队列
dispatch_async(globalQueue, ^{
// taskA
});
dispatch_async(globalQueue, ^{
// taskB
dispatch_async(globalQueue, ^{
// taskC
});
//会开辟多条线程执行任务，线程数量由系统决定，线程开始和结束的时间都是随机的
GCD常用函数
1.GCD延迟函数
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 5秒后异步执行
});
2.GCD栅栏函数
场景：任务都是异步执行的，但是执行的任务分为2组，第一组异步执行完后开始执行第二组任务
注意：栅栏函数不能使用全局并发队列，需要自己创建队列（使用全局并发队列后发现栅栏函数不起作用了）
- (void)GCDAction:(id)sender {
//dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 并发队列
dispatch_queue_t queue = dispatch_queue_create("queuelll", DISPATCH_QUEUE_CONCURRENT);
// 异步执行
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"栅栏：1 %@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"栅栏：2 %@",[NSThread currentThread]);
}
});
dispatch_barrier_async(queue, ^{
NSLog(@"End barrier:%@", [NSThread currentThread]);
NSLog(@"******* 并发执行，但是34一定在12后面 *********");
});
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"栅栏：3 %@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"栅栏：4 %@",[NSThread currentThread]);
}
});
}
3.GCD dispatch_once函数
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
NSLog(@"once");
});
4.GCD队列组 dispatch_group_notify函数
场景：异步几个结束后回到主线程
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
NSLog(@"队列组：A);
});
dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
NSLog(@"队列组：B！");
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"队列组：回到主线程");
});
总结
GCD中任务执行顺序和线程开启情况受操作方式和队列类型2个因素影响
- 👉1线程开启情况
同步sync操作不开启线程；异步操作async开启线程（主队列除外），串行队列开启一条线程(当前代码上下文)，异步队列开启至少一条线程(当前代码上下文)，数量由系统决定
思考：异步操作并发队列中线程的开启数量由系统判断（当前代码上下文至少开启一条线程）
如下代码：代码中仅仅一句nslog的有无就可能决定是否多开启一条线程
//如下代码：开启一条线程
dispatch_queue_t Queue2 = dispatch_queue_create("yflConss", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(Queue2, ^{
NSLog(@"A%@",[NSThread currentThread]);
dispatch_async(Queue2, ^{
NSLog(@"B%@",[NSThread currentThread]);
});
// NSLog(@"JJ");
});
//如下代码：开启2条线程
dispatch_queue_t Queue2 = dispatch_queue_create("yflConss", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(Queue2, ^{
NSLog(@"A%@",[NSThread currentThread]);
dispatch_async(Queue2, ^{
NSLog(@"B%@",[NSThread currentThread]);
});
NSLog(@"JJ");
});
//开启2条线程
dispatch_queue_t Queue2 = dispatch_queue_create("yflConss", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(Queue2, ^{
NSLog(@"A%@",[NSThread currentThread]);
});
dispatch_async(Queue2, ^{
NSLog(@"B%@",[NSThread currentThread]);
});
👉2任务执行顺序
串行队列顺序执行，并发队列在同步操作sync中顺序执行，在异步操作async中异步执行
- 线程是否开始和操作类型有关，任务执行顺序由操作类型和队列类型2个因素有关（同步操作都是顺序执行；串行队列都是顺序执行；只有异步并发队列才是异步执行）
