多个网络请求-并发执行、顺序执行
前言
我们在开发的过程中，大家应该都会遇到已进入某个页面，就要请求多个API，然后我们在完成所有请求以后再进行其他操作，对于这种需求，我们如何来设计我们的代码呢？
例如有以下的场景，在某个页面有5个模块，但是后端给的接口又是分别不同的接口来调用，多个网络请求之后才能更新UI。
一、并发执行
多个网络请求同时执行，等所有网络请求完成，再统一做其他操作，你可能会想到dispatch_group_async、dispatch_group_notify结合使用，如下：
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^{
NSLog(@"任务一完成");
});
dispatch_group_async(group, queue, ^{
NSLog(@"任务二完成");
});
dispatch_group_async(group, queue, ^{
NSLog(@"任务三完成");
});
//在分组的所有任务完成后触发
dispatch_group_notify(group, queue, ^{
NSLog(@"所有任务完成");
});
打印结果：
2021-03-17 17:04:59.579806+0800 车马[40978:355298] 任务二完成 2021-03-17 17:04:59.579806+0800 车马[40978:355304] 任务一完成 2021-03-17 17:04:59.579808+0800 车马[40978:355302] 任务三完成 2021-03-17 17:04:59.579968+0800 车马[40978:355304] 所有任务完成
由于三个任务都是异步的，所有返回结果顺序不一定是正序，看似却确实实现了我们的需求，但是网络请求是异步的，耗时的，不是马上就能返回结果的，如下使用dispatch_after模拟网络请求的延迟：
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^{
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"任务一完成");
});
});
dispatch_group_async(group, queue, ^{
NSLog(@"任务二完成");
});
dispatch_group_async(group, queue, ^{
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"任务三完成");
});
});
//在分组的所有任务完成后触发
dispatch_group_notify(group, queue, ^{
NSLog(@"所有任务完成");
});
打印结果：
2021-03-17 17:08:21.021212+0800 车马[41081:357903] 任务二完成 2021-03-17 17:08:21.021389+0800 车马[41081:357903] 所有任务完成 2021-03-17 17:08:22.119416+0800 车马[41081:357432] 任务三完成 2021-03-17 17:08:23.217752+0800 车马[41081:357432] 任务一完成
可看到任务一的延迟请求完成造成了一些问题，这时候我们可以用信号量即dispatch_semaphore，
dispatch_semaphore是GCD用来同步的一种方式，与他相关的共有三个函数，分别是dispatch_semaphore_create，dispatch_semaphore_signal，dispatch_semaphore_wait。
下面我们逐一介绍三个函数解释：
（1）dispatch_semaphore_create的声明为：
dispatch_semaphore_t dispatch_semaphore_create(long value);
传入的参数为long，输出一个dispatch_semaphore_t类型且值为value的信号量。
值得注意的是，这里的传入的参数value必须大于或等于0，否则dispatch_semaphore_create会返回NULL。
（关于信号量，我就不在这里累述了，网上很多介绍这个的。我们这里主要讲一下dispatch_semaphore这三个函数的用法）。
（2）dispatch_semaphore_signal的声明为：
long dispatch_semaphore_signal(dispatch_semaphore_t dsema)
这个函数会使传入的信号量dsema的值加1；（至于返回值，待会儿再讲）
(3) dispatch_semaphore_wait的声明为：
long dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout)；
这个函数会使传入的信号量dsema的值减1；
这个函数的作用是这样的，如果dsema信号量的值大于0，该函数所处线程就继续执行下面的语句，并且将信号量的值减1；
如果desema的值为0，那么这个函数就阻塞当前线程等待timeout（注意timeout的类型为dispatch_time_t，
不能直接传入整形或float型数），如果等待的期间desema的值被dispatch_semaphore_signal函数加1了，
且该函数（即dispatch_semaphore_wait）所处线程获得了信号量，那么就继续向下执行并将信号量减1。
如果等待期间没有获取到信号量或者信号量的值一直为0，那么等到timeout时，其所处线程自动执行其后语句。
（4）dispatch_semaphore_signal的返回值为long类型，当返回值为0时表示当前并没有线程等待其处理的信号量，其处理
的信号量的值加1即可。当返回值不为0时，表示其当前有（一个或多个）线程等待其处理的信号量，并且该函数唤醒了一
个等待的线程（当线程有优先级时，唤醒优先级最高的线程；否则随机唤醒）。
dispatch_semaphore_wait的返回值也为long型。当其返回0时表示在timeout之前，该函数所处的线程被成功唤醒。
当其返回不为0时，表示timeout发生。
（5）在设置timeout时，比较有用的两个宏：DISPATCH_TIME_NOW 和 DISPATCH_TIME_FOREVER。
DISPATCH_TIME_NOW 表示当前；
DISPATCH_TIME_FOREVER 表示遥远的未来；
一般可以直接设置timeout为这两个宏其中的一个，或者自己创建一个dispatch_time_t类型的变量。
创建dispatch_time_t类型的变量有两种方法，dispatch_time和dispatch_walltime。
利用创建dispatch_time创建dispatch_time_t类型变量的时候一般也会用到这两个变量。
dispatch_time的声明如下：
dispatch_time_t dispatch_time(dispatch_time_t when, int64_t delta)；
其参数when需传入一个dispatch_time_t类型的变量，和一个delta值。表示when加delta时间就是timeout的时间。
例如：dispatch_time_t t = dispatch_time(DISPATCH_TIME_NOW, 1*1000*1000*1000);
表示当前时间向后延时一秒为timeout的时间。
（6）关于信号量，一般可以用停车来比喻。
停车场剩余4个车位，那么即使同时来了四辆车也能停的下。如果此时来了五辆车，那么就有一辆需要等待。
信号量的值就相当于剩余车位的数目，dispatch_semaphore_wait函数就相当于来了一辆车，dispatch_semaphore_signal
就相当于走了一辆车。停车位的剩余数目在初始化的时候就已经指明了（dispatch_semaphore_create（long value）），
调用一次dispatch_semaphore_signal，剩余的车位就增加一个；调用一次dispatch_semaphore_wait剩余车位就减少一个；
当剩余车位为0时，再来车（即调用dispatch_semaphore_wait）就只能等待。有可能同时有几辆车等待一个停车位。有些车主
没有耐心，给自己设定了一段等待时间，这段时间内等不到停车位就走了，如果等到了就开进去停车。而有些车主就像把车停在这，
所以就一直等下去。
代码示例：
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_semaphore_t sem = dispatch_semaphore_create(0);
dispatch_group_async(group, queue, ^{
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
dispatch_semaphore_signal(sem);
NSLog(@"请求一完成");
});
dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
});
dispatch_group_async(group, queue, ^{
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.8 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
dispatch_semaphore_signal(sem);
NSLog(@"请求二完成");
});
dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
});
dispatch_group_async(group, queue, ^{
NSLog(@"请求三完成");
});
//在分组的所有任务完成后触发
dispatch_group_notify(group, queue, ^{
NSLog(@"所有请求完成");
});
打印结果：
2021-03-17 17:12:52.036116+0800 车马[41213:360928] 请求三完成 2021-03-17 17:12:52.836120+0800 车马[41213:360464] 请求二完成 2021-03-17 17:12:53.134471+0800 车马[41213:360464] 请求一完成 2021-03-17 17:12:53.134509+0800 车马[41213:360925] 所有请求完成
就实现了我们的需求(多个网络请求都完成再做其他操作),当然也可以通过dispatch_group_enter、dispatch_group_leave结合实现，使用dispatch_group_enter()函数进入到任务组中，然后异步执行队列中的任务，最后使用dispatch_group_leave()函数离开任务组即可，
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
dispatch_group_enter(group);
dispatch_group_async(group, queue, ^{
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"任务1");
dispatch_group_leave(group);
});
});
dispatch_group_enter(group);
dispatch_group_async(group, queue, ^{
NSLog(@"任务2");
dispatch_group_leave(group);
});
dispatch_group_enter(group);
dispatch_group_async(group, queue, ^{
NSLog(@"任务3");
dispatch_group_leave(group);
});
dispatch_group_notify(group, queue, ^{
NSLog(@"完成");
});
打印结果：
2021-03-17 17:16:14.115544+0800 车马[41340:365194] 任务2 2021-03-17 17:16:14.115677+0800 车马[41340:365194] 任务3 2021-03-17 17:16:15.212239+0800 车马[41340:364732] 任务1 2021-03-17 17:16:15.212388+0800 车马[41340:365194] 完成
同样实现了我们需求
二、顺序执行
仍然通过信号量执行，执行任务一，将信号量dispatch_semaphore_wait减一，请求完成，再dispatch_semaphore_signal加一，一次类推，
代码实现：
dispatch_semaphore_t sema = dispatch_semaphore_create(1);
dispatch_queue_t queue = dispatch_queue_create("testQueue", NULL);
dispatch_async(queue, ^{
dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"任务1");
dispatch_semaphore_signal(sema);
});
});
dispatch_async(queue, ^{
dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
NSLog(@"任务2");
dispatch_semaphore_signal(sema);
});
dispatch_async(queue, ^{
dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(4 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"任务3");
dispatch_semaphore_signal(sema);
});
});
dispatch_async(queue, ^{
dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
NSLog(@"任务4");
dispatch_semaphore_signal(sema);
});
打印结果：
2021-03-17 17:18:54.815350+0800 车马[41430:366951] 任务1 2021-03-17 17:18:54.815515+0800 车马[41430:367412] 任务2 2021-03-17 17:18:58.114266+0800 车马[41430:366951] 任务3 2021-03-17 17:18:58.114425+0800 车马[41430:367412] 任务4
