1.GCD简介
Grand Central Dispatch（GCD）是 Apple 开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并发任务。在 Mac OS X 10.6 雪豹中首次推出，也可在 iOS 4 及以上版本使用。
2.队列与任务
2.1 队列
队列（Dispatch Queue）：这里的队列指执行任务的等待队列，即用来存放任务的队列。队列是一种特殊的线性表，采用 FIFO（先进先出）的原则，即新任务总是被插入到队列的末尾，而读取任务的时候总是从队列的头部开始读取。每读取一个任务，则从队列中释放一个任务。
在 GCD 中有两种队列：『串行队列』和『并发队列』。两者都符合 FIFO（先进先出）的原则。两者的主要区别是：执行顺序不同，以及开启线程数不同。
串行队列（Serial Dispatch Queue）：每次只有一个任务被执行。让任务一个接着一个地执行。（只开启一个线程，一个任务执行完毕后，再执行下一个任务）。主队列的实质上就是一个普通的串行队列，只是因为默认情况下，当前代码是放在主队列中的，然后主队列中的代码，有都会放到主线程中去执行，所以才造成了主队列特殊的现象。
并发队列（Concurrent Dispatch Queue）：可以让多个任务并发（同时）执行。（可以开启多个线程，并且同时执行任务）。
注意：并发队列的并发功能只有在异步（dispatch_async）方法下才有效。
2.1.1 创建队列
获取主队列：dispatch_queue_t queue = dispatch_get_main_queue(); 主队列系统已经创建好直接获取即可，主队列放在主线程中执行。
串行对列的创建方法：dispatch_queue_t queue = dispatch_queue_create("com.gcdexample.testQueue", DISPATCH_QUEUE_SERIAL);
并发队列的创建方法：dispatch_queue_t queue = dispatch_queue_create("com.gcdexample.testQueue", DISPATCH_QUEUE_CONCURRENT);
参数说明：
第一个参数表示队列的唯一标识符，用于 DEBUG，可为空。队列的名称推荐使用应用程序 ID 这种逆序全程域名。
第二个参数用来识别是串行队列还是并发队列。DISPATCH_QUEUE_SERIAL或null表示串行队列，DISPATCH_QUEUE_CONCURRENT表示并发队列。
获取全局并发队列：dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);GCD默认已经提供了全局的并发队列，供整个应用使用，不需要手动创建
使用说明：
使用dispatch_get_global_queue方法来获取全局并发队列。需要传入两个参数。第一个参数表示队列优先级，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二个参数暂时没用，用0即可。
2.2 任务
任务：就是我们在线程中执行的操作（代码）。执行任务有两种方式：『同步执行』和『异步执行』。两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。
同步执行（sync）：同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等待，直到队列里面的任务完成之后再继续执行。只能在当前线程中执行任务，不具备开启新线程的能力。
异步执行（async）：异步添加任务到指定的队列中，它不会做任何等待，可以继续执行任务。可以在新的线程中执行任务，具备开启新线程的能力。
2.2.1 创建任务
同步执行任务创建方法：
dispatch_sync(queue, ^{
//任务代码
});
异步执行任务创建方法：
dispatch_async(queue, ^{
// 任务代码
});
3.队列与任务的不同组合
3.1 同步执行 + 并发队列
在当前线程中执行任务，不会开启新线程，执行完一个任务，再执行下一个任务。
- (void)syncConcurrent {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"syncConcurrent---begin");
dispatch_queue_t queue = dispatch_queue_create("com.gcdexample.testQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_sync(queue, ^{
// 追加任务 1
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
});
dispatch_sync(queue, ^{
// 追加任务 2
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
});
dispatch_sync(queue, ^{
// 追加任务 3
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
});
NSLog(@"syncConcurrent---end");
}
输出结果：
2019-12-08 14:32:53.542816+0800 GCD-demo[16332:4171500] currentThread---{number = 1, name = main}
2019-12-08 14:32:53.542964+0800 GCD-demo[16332:4171500] syncConcurrent---begin
2019-12-08 14:32:55.544329+0800 GCD-demo[16332:4171500] 1---{number = 1, name = main}
2019-12-08 14:32:57.545779+0800 GCD-demo[16332:4171500] 2---{number = 1, name = main}
2019-12-08 14:32:59.547154+0800 GCD-demo[16332:4171500] 3---{number = 1, name = main}
2019-12-08 14:32:59.547365+0800 GCD-demo[16332:4171500] syncConcurrent---end
3.2 异步执行 + 并发队列
可以开启多个线程，任务交替（同时）执行。
- (void)asyncConcurrent {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"asyncConcurrent---begin");
dispatch_queue_t queue = dispatch_queue_create("com.gcdexample.testQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
// 追加任务 1
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
});
dispatch_async(queue, ^{
// 追加任务 2
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
});
dispatch_async(queue, ^{
// 追加任务 3
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
});
NSLog(@"asyncConcurrent---end");
}
输出结果：
2019-12-08 14:36:37.747966+0800 GCD-demo[17232:4187114] currentThread---{number = 1, name = main}
2019-12-08 14:36:37.748150+0800 GCD-demo[17232:4187114] asyncConcurrent---begin
2019-12-08 14:36:37.748279+0800 GCD-demo[17232:4187114] asyncConcurrent---end
2019-12-08 14:36:39.752523+0800 GCD-demo[17232:4187204] 2---{number = 3, name = (null)}
2019-12-08 14:36:39.752527+0800 GCD-demo[17232:4187202] 3---{number = 5, name = (null)}
2019-12-08 14:36:39.752527+0800 GCD-demo[17232:4187203] 1---{number = 4, name = (null)}
3.3 同步执行 + 串行队列
不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务。
- (void)syncSerial {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"syncSerial---begin");
dispatch_queue_t queue = dispatch_queue_create("com.gcdexample.testQueue", DISPATCH_QUEUE_SERIAL);
dispatch_sync(queue, ^{
// 追加任务 1
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
});
dispatch_sync(queue, ^{
// 追加任务 2
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
});
dispatch_sync(queue, ^{
// 追加任务 3
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
});
NSLog(@"syncSerial---end");
}
输出结果为：
2019-12-08 14:39:31.366815+0800 GCD-demo[17285:4197645] currentThread---{number = 1, name = main}
2019-12-08 14:39:31.366952+0800 GCD-demo[17285:4197645] syncSerial---begin
2019-12-08 14:39:33.368256+0800 GCD-demo[17285:4197645] 1---{number = 1, name = main}
2019-12-08 14:39:35.369661+0800 GCD-demo[17285:4197645] 2---{number = 1, name = main}
2019-12-08 14:39:37.370991+0800 GCD-demo[17285:4197645] 3---{number = 1, name = main}
2019-12-08 14:39:37.371192+0800 GCD-demo[17285:4197645] syncSerial---end
3.4 异步执行 + 串行队列
会开启一条新线程，但是因为任务是串行的，执行完一个任务，再执行下一个任务。
- (void)asyncSerial {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"asyncSerial---begin");
dispatch_queue_t queue = dispatch_queue_create("com.gcdexample.testQueue", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{
// 追加任务 1
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
});
dispatch_async(queue, ^{
// 追加任务 2
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
});
dispatch_async(queue, ^{
// 追加任务 3
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
});
NSLog(@"asyncSerial---end");
}
输出结果为：
2019-12-08 14:40:53.944502+0800 GCD-demo[17313:4203018] currentThread---{number = 1, name = main}
2019-12-08 14:40:53.944615+0800 GCD-demo[17313:4203018] asyncSerial---begin
2019-12-08 14:40:53.944710+0800 GCD-demo[17313:4203018] asyncSerial---end
2019-12-08 14:40:55.947709+0800 GCD-demo[17313:4203079] 1---{number = 3, name = (null)}
2019-12-08 14:40:57.952453+0800 GCD-demo[17313:4203079] 2---{number = 3, name = (null)}
2019-12-08 14:40:59.952943+0800 GCD-demo[17313:4203079] 3---{number = 3, name = (null)}
3.5 同步执行 + 主队列
在不同线程中调用结果也是不一样，如果在主线程中被调用会造成死锁现象。
- (void)syncMain {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"syncMain---begin");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
// 追加任务 1
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
});
dispatch_sync(queue, ^{
// 追加任务 2
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
});
dispatch_sync(queue, ^{
// 追加任务 3
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
});
NSLog(@"syncMain---end");
}
输出结果
2019-12-08 14:43:58.062376+0800 GCD-demo[17371:4213562] currentThread---{number = 1, name = main}
2019-12-08 14:43:58.062518+0800 GCD-demo[17371:4213562] syncMain---begin
(lldb)
崩溃原因：因为我们在主线程中执行syncMain方法，相当于把syncMain任务放到了主线程的队列中。而同步执行会等待当前队列中的任务执行完毕，才会接着执行。那么当我们把任务 1追加到主队列中，任务 1就在等待主线程处理完syncMain任务。而syncMain任务需要等待任务 1执行完毕，才能接着执行。这就造成了相互等待的情况，所以就卡死了。
该组合在其他线程中被调用，不会开启新的线程，任务会被串行执行。
// 使用 NSThread 的 detachNewThreadSelector 方法会创建线程，并自动启动线程执行 selector 任务
[NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];
输出结果：
2019-12-08 14:51:38.137978+0800 GCD-demo[17482:4237818] currentThread---{number = 3, name = (null)}
2019-12-08 14:51:38.138159+0800 GCD-demo[17482:4237818] syncMain---begin
2019-12-08 14:51:40.149065+0800 GCD-demo[17482:4237594] 1---{number = 1, name = main}
2019-12-08 14:51:42.151104+0800 GCD-demo[17482:4237594] 2---{number = 1, name = main}
2019-12-08 14:51:44.152583+0800 GCD-demo[17482:4237594] 3---{number = 1, name = main}
2019-12-08 14:51:44.152767+0800 GCD-demo[17482:4237818] syncMain---end
结果分析：因为syncMain 任务放到了其他线程里，而任务 1、任务 2、任务3都再追加到主队列中，这三个任务都会在主线程中执行。syncMain 任务在其他线程中执行到追加任务 1到主队列中，因为主队列现在没有正在执行的任务，所以，会直接执行主队列的任务1，等任务1执行完毕，再接着执行任务 2、任务 3。所以这里不会卡住线程，也就不会造成死锁问题。
3.6 异步执行 + 主队列
只在主线程中执行任务不会开启新线程，任务一个接一个执行。
- (void)asyncMain {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"asyncMain---begin");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_async(queue, ^{
// 追加任务 1
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
});
dispatch_async(queue, ^{
// 追加任务 2
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
});
dispatch_async(queue, ^{
// 追加任务 3
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
});
NSLog(@"asyncMain---end");
}
输出结果：
2019-12-08 14:53:27.023091+0800 GCD-demo[17521:4243690] currentThread---{number = 1, name = main}
2019-12-08 14:53:27.023247+0800 GCD-demo[17521:4243690] asyncMain---begin
2019-12-08 14:53:27.023399+0800 GCD-demo[17521:4243690] asyncMain---end
2019-12-08 14:53:29.035565+0800 GCD-demo[17521:4243690] 1---{number = 1, name = main}
2019-12-08 14:53:31.036565+0800 GCD-demo[17521:4243690] 2---{number = 1, name = main}
2019-12-08 14:53:33.037092+0800 GCD-demo[17521:4243690] 3---{number = 1, name = main}
4.队列嵌套
对列嵌套的情况比较复杂，这里只做一下同一队列的嵌套情况，帮助参考。
dispatch_queue_t queue=dispatch_queue_create("exam.queue",DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{ // 异步执行 + 串行队列
dispatch_async(queue, ^{ // 同步执行 + 当前串行队列
[NSThread sleepForTimeInterval:2];// 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]);// 打印当前线程
});
});
死锁说明：该案例造成死锁的原理，同主队列+同步执行造成死锁的原因一样，都是因为相互等待造成的。
5.栅栏方法：dispatch_barrier_async
我们有时需要异步执行两组操作，而且第一组操作执行完之后，才能开始执行第二组操作。这样我们就需要一个相当于 栅栏 一样的一个方法将两组异步执行的操作组分割起来，当然这里的操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async方法在两个操作组间形成栅栏。
dispatch_barrier_async函数会等待前边追加到并发队列中的任务全部执行完毕之后，再将指定的任务追加到该异步队列中。然后在dispatch_barrier_async函数追加的任务执行完毕之后，异步队列才恢复为一般动作，接着追加任务到该异步队列并开始执行。
- (void)barrier {
dispatch_queue_t queue = dispatch_queue_create("com.gcdexample.testQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
// 追加任务 1
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
});
dispatch_async(queue, ^{
// 追加任务 2
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
});
dispatch_barrier_async(queue, ^{
// 追加任务 barrier
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"barrier---%@",[NSThread currentThread]);// 打印当前线程
});
dispatch_async(queue, ^{
// 追加任务 3
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
});
dispatch_async(queue, ^{
// 追加任务 4
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"4---%@",[NSThread currentThread]); // 打印当前线程
});
}
输出结果：
2019-12-08 14:59:02.540868+0800 GCD-demo[17648:4262933] 1---{number = 3, name = (null)}
2019-12-08 14:59:02.540868+0800 GCD-demo[17648:4262932] 2---{number = 4, name = (null)}
2019-12-08 14:59:04.542346+0800 GCD-demo[17648:4262933] barrier---{number = 3, name = (null)}
2019-12-08 14:59:06.542772+0800 GCD-demo[17648:4262932] 4---{number = 4, name = (null)}
2019-12-08 14:59:06.542773+0800 GCD-demo[17648:4262933] 3---{number = 3, name = (null)}
6.GCD线程之间的通讯
在 iOS 开发过程中，我们一般在主线程里边进行 UI 刷新，例如：点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程，比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时，需要回到主线程，那么就用到了线程之间的通讯。
通过以下例子我们可以看到在其他线程执行完任务后回到主线程：
- (void)communicate {
// 获取全局并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 获取主队列
dispatch_queue_t mainQueue = dispatch_get_main_queue();
dispatch_async(queue, ^{
// 异步追加任务 1
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
// 回到主线程
dispatch_async(mainQueue, ^{
// 追加在主线程中执行的任务
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
});
});
}
输出结果：
2019-12-08 14:56:22.973318+0800 GCD-demo[17573:4253201] 1---{number = 3, name = (null)}
2019-12-08 14:56:24.973902+0800 GCD-demo[17573:4253108] 2---{number = 1, name = main}
7.GCD常用方法
7.1GCD 延时执行方法：dispatch_after
GCD 的dispatch_after可以用来实现在延迟执行某个操作（代码）。
需要注意的是：dispatch_after方法并不是在指定时间之后才开始执行处理，而是在指定时间之后将任务追加到主队列中。严格来说，这个时间并不是绝对准确的，但想要大致延迟执行任务，dispatch_after方法是很有效的。
- (void)after {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"asyncMain---begin");
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 2.0 秒后异步追加任务代码到主队列，并开始执行
NSLog(@"after---%@",[NSThread currentThread]); // 打印当前线程
});
}
输出结果：
2019-12-08 15:01:33.569710+0800 GCD-demo[17702:4272430] currentThread---{number = 1, name = main}
2019-12-08 15:01:33.569838+0800 GCD-demo[17702:4272430] asyncMain---begin
2019-12-08 15:01:35.570146+0800 GCD-demo[17702:4272430] after---{number = 1, name = main}
7.2 GCD 一次性代码（只执行一次）：dispatch_once
我们在创建单例、或者有整个程序运行过程中只执行一次的代码时，我们就用到了 GCD 的dispatch_once方法。使用dispatch_once方法能保证某段代码在程序运行过程中只被执行1次，并且即使在多线程的环境下，dispatch_once也可以保证线程安全。
- (void)once {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
// 只执行 1 次的代码（这里面默认是线程安全的）
});
}
7.3 GCD 快速迭代方法：dispatch_apply
通常我们会用 for 循环遍历，但是 GCD 给我们提供了快速迭代的方法dispatch_apply。dispatch_apply按照指定的次数将指定的任务追加到指定的队列中，并等待全部队列执行结束。
如果是在串行队列中使用dispatch_apply，那么就和 for 循环一样，按顺序同步执行。但是这样就体现不出快速迭代的意义了。
我们可以利用并发队列进行异步执行。比如说遍历 0~5 这 6 个数字，for 循环的做法是每次取出一个元素，逐个遍历。dispatch_apply可以 在多个线程中同时（异步）遍历多个数字。
还有一点，无论是在串行队列，还是并发队列中，dispatch_apply 都会等待全部任务执行完毕，再向下执行。
- (void)apply {
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
NSLog(@"apply---begin");
dispatch_apply(6, queue, ^(size_t index) {
NSLog(@"%zd---%@",index, [NSThread currentThread]);
});
NSLog(@"apply---end");
}
输出结果：
2019-12-08 15:05:04.715266+0800 GCD-demo[17771:4285619] apply---begin
2019-12-08 15:05:04.715492+0800 GCD-demo[17771:4285619] 0---{number = 1, name = main}
2019-12-08 15:05:04.715516+0800 GCD-demo[17771:4285722] 1---{number = 3, name = (null)}
2019-12-08 15:05:04.715526+0800 GCD-demo[17771:4285720] 3---{number = 5, name = (null)}
2019-12-08 15:05:04.715564+0800 GCD-demo[17771:4285721] 2---{number = 7, name = (null)}
2019-12-08 15:05:04.715555+0800 GCD-demo[17771:4285719] 4---{number = 6, name = (null)}
2019-12-08 15:05:04.715578+0800 GCD-demo[17771:4285728] 5---{number = 4, name = (null)}
2019-12-08 15:05:04.715677+0800 GCD-demo[17771:4285619] apply---end
7.4 GCD定时器
说到定时器我们首先想到到是NSTimer，但是NSTimer往往会出现一些bug，受runloop的影响NSTimer会出现定时不准确，以及在滚动视图滚动的时候会定时会自动停止等情况。所以我们最好选择GCD的定时器来进行定时。
GCD定时器之所以准确，简单来说是因为是系统级别的调用，不受其他事件影响。（深入了解可以看下dispatch_source）
GCD定时器是dispatch_source_t类型的变量，其可以实现更加精准的定时效果。我们来看看如何使用:/** 创建定时器对象
* para1: DISPATCH_SOURCE_TYPE_TIMER 为定时器类型
* para2-3: 中间两个参数对定时器无用
* para4: 最后为在什么调度队列中使用
*/_gcdTimer=dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER,0,0,dispatch_get_global_queue(0,0));/** 设置定时器
* para2: 任务开始时间
* para3: 任务的间隔
* para4: 可接受的误差时间，设置0即不允许出现误差
* Tips: 单位均为纳秒
*/dispatch_source_set_timer(_gcdTimer,DISPATCH_TIME_NOW,2.0*NSEC_PER_SEC,0.0*NSEC_PER_SEC);/** 设置定时器任务
* 可以通过block方式
* 也可以通过C函数方式
*/dispatch_source_set_event_handler(_gcdTimer,^{staticint gcdIdx=0;NSLog(@"GCD Method: %d",gcdIdx++);NSLog(@"%@",[NSThread currentThread]);if(gcdIdx==5){// 终止定时器dispatch_suspend(_gcdTimer);}});// 启动任务，GCD计时器创建后需要手动启动dispatch_resume(_gcdTimer);
7.5 dispatch_group
dispatch_group指的是队列组，通常情况下有三种用法。在我们有类似如下需求的时候考虑使用，分别异步执行2个耗时任务，然后当2个耗时任务都执行完毕后再回到主线程执行任务或则再向下继续执行。
注意：dispatch_group_enter、dispatch_group_leave 组合，其实等同于dispatch_group_async，相当于先把任务放到队列中，然后将队列放入队列组中。在下面的案例中会有所体现。
一种是配合dispatch_group_notify使用，dispatch_group_notify会监听group 中任务的完成状态，当所有的任务都执行完成后，再追加新的任务到 group 中，并执行任务。
- (void)groupExam {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"group---begin");
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任务 1
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任务 2
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
// 等前面的异步任务 1、任务 2 都执行完毕后，回到主线程执行下边任务
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"group---end");
});
}
输出结果：
2019-08-08 15:07:21.601734+0800 GCD-demo[17813:4293874] currentThread---{number = 1, name = main}
2019-12-08 15:07:21.601871+0800 GCD-demo[17813:4293874] group---begin
2019-12-08 15:07:23.604854+0800 GCD-demo[17813:4294048] 2---{number = 4, name = (null)}
2019-12-08 15:07:23.604852+0800 GCD-demo[17813:4294053] 1---{number = 3, name = (null)}
2019-12-08 15:07:25.606067+0800 GCD-demo[17813:4293874] 3---{number = 1, name = main}
2019-12-08 15:07:25.606255+0800 GCD-demo[17813:4293874] group---end
另一种是配合dispatch_group_wait使用，dispatch_group_wait会暂停当前线程（阻塞当前线程），等待指定的 group 中的任务执行完成后，才会往下继续执行。
- (void)groupWaitExam {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"group---begin");
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任务 1
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任务 2
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
});
// 等待上面的任务全部完成后，会往下继续执行（会阻塞当前线程）
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
NSLog(@"group---end");
}
输出结果：
2019-12-08 15:09:12.441729+0800 GCD-demo[17844:4299926] currentThread---{number = 1, name = main}
2019-12-08 15:09:12.441870+0800 GCD-demo[17844:4299926] group---begin
2019-12-08 15:09:14.445790+0800 GCD-demo[17844:4300046] 2---{number = 4, name = (null)}
2019-12-08 15:09:14.445760+0800 GCD-demo[17844:4300043] 1---{number = 3, name = (null)}
2019-12-08 15:09:14.446039+0800 GCD-demo[17844:4299926] group---end
最后一种是配合 dispatch_group_enter、dispatch_group_leave使用，dispatch_group_enter标志着一个任务追加到 group，执行一次，相当于 group 中未执行完毕任务数 +1，dispatch_group_leave标志着一个任务离开了 group，执行一次，相当于 group 中未执行完毕任务数 -1。
- (void)groupEnterAndLeave {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"group---begin");
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_enter(group);
dispatch_async(queue, ^{
// 追加任务 1
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
dispatch_group_leave(group);
});
dispatch_group_enter(group);
dispatch_async(queue, ^{
// 追加任务 2
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
dispatch_group_leave(group);
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
// 等前面的异步操作都执行完毕后，回到主线程.
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"group---end");
});
}
输出结果：
2019-12-08 15:13:17.983283+0800 GCD-demo[17924:4314716] currentThread---{number = 1, name = main}
2019-12-08 15:13:17.983429+0800 GCD-demo[17924:4314716] group---begin
2019-12-08 15:13:19.988898+0800 GCD-demo[17924:4314816] 2---{number = 3, name = (null)}
2019-12-08 15:13:19.988888+0800 GCD-demo[17924:4314808] 1---{number = 4, name = (null)}
2019-12-08 15:13:21.990450+0800 GCD-demo[17924:4314716] 3---{number = 1, name = main}
2019-12-08 15:13:21.990711+0800 GCD-demo[17924:4314716] group---end
8.GCD 信号量：dispatch_semaphore
GCD 中的信号量是指Dispatch Semaphore----是持有计数的信号。信号计数小于 0 时阻塞当前线程，不可通过。计数为 0 或大于 0 时，计数减 1 且不等待，可通过。
Dispatch Semaphore 在实际开发中主要用于：
1.保持线程同步，将异步执行任务转换为同步执行任务
2.保证线程安全，为线程加锁
Dispatch Semaphore 提供了三个方法：
1.dispatch_semaphore_create的声明为：dispatch_semaphore_t dispatch_semaphore_create(long value);
传入的参数为long，输出一个dispatch_semaphore_t类型且值为value的信号量。
值得注意的是，这里的传入的参数value必须大于或等于0，否则dispatch_semaphore_create会返回NULL。
2.dispatch_semaphore_signal的声明为：dispatch_semaphore_signal(dispatch_semaphore_t dsema)；
这个函数会使传入的信号量dsema的值加1；
3.dispatch_semaphore_wait的声明为：dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout)；
这个函数会使传入的信号量dsema的值减1；
这个函数的作用是这样的，如果dsema信号量的值大于0或等于0，该函数所处线程就继续执行下面的语句，并且将信号量的值减1；
如果desema的值小于0，那么这个函数就阻塞当前线程等待timeout（注意timeout的类型dispatch_time_t，不能直接传入整形或float型数），如果等待的期间desema的值被dispatch_semaphore_signal函数加1了，且该函数（即dispatch_semaphore_wait）所处线程获得了信号量，那么就继续向下执行并将信号量减1。如果等待期间没有获取到信号量或者信号量的值一直为0，那么等到timeout时，其所处线程自动执行气候语句。
下面这个案例可以体现（线程同步，线程安全，以及三个函数的用法）：
- (void)semaphoreSync {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"semaphore---begin");
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
__block int number = 0;
dispatch_async(queue, ^{
// 追加任务 1
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
number = 100;
dispatch_semaphore_signal(semaphore);
});
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
NSLog(@"semaphore---end,number = %zd",number);
}
输出结果：
2019-12-08 15:16:56.781543+0800 GCD-demo[17988:4325744] currentThread---{number = 1, name = main}
2019-12-08 15:16:56.781698+0800 GCD-demo[17988:4325744] semaphore---begin
2019-12-08 15:16:58.785232+0800 GCD-demo[17988:4325867] 1---{number = 3, name = (null)}
2019-12-08 15:16:58.785432+0800 GCD-demo[17988:4325744] semaphore---end,number = 100。
以上代码执行流程：
1.semaphore 初始创建时计数为 0。
2.异步执行将任务 1追加到队列之后，不做等待，接着执行dispatch_semaphore_wait方法，semaphore 减 1，此时semaphore == -1，当前线程进入等待状态。
3.然后，异步任务 1 开始执行。任务 1 执行到dispatch_semaphore_signal之后，总信号量加 1，此时semaphore == 0，正在被阻塞的线程（主线程）恢复继续执行。
4.最后打印semaphore---end,number = 100。
