前段时间学习了一下GCD相关的知识，看了不少同学写的Blog，通过使用dispatch_group和dispatch_semaphore解决网络请求同步、异步问题，让我受益良多，也激发了我的思考。
我提出了一种问题场景
多请求异步发起，要求其回调按顺序执行。
题目很简单，为了能方便大家的理解，我举个栗子：A、B、C三个网络请求，一同发出，当然它们请求回来的时间肯定是不一致的，但是我希望三个网络请求对应的blockA、blockB、blockC是按照顺序执行的。
也就是说就算网络请求B回来了，但是A没回来，blockB也要等着A请求的blockA先执行完才能执行。
我想我的问题已经描述的很清楚了，不知道读到这里同学们有没有想法？
可以思考一下，当然！其实你使用各种标识符控制、i++计量、请求任务的Block中嵌套另一个请求任务的发起动作等……方法是可以解决这种场景问题。但是！既然是为了学习，就不要把为了规避问题当做第一要务。
接下来我说一下我的处理办法，可能不是最好的办法，也就是为大家提供一个思路。
1. 首先我们模拟一下网络请求
此处模拟网络求情写的有点复杂了，之所以加到并行队列中是想体现这三个网络请求是异步并发的。
dispatch_queue_t requestQueue = dispatch_queue_create("com.requestQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(requestQueue, ^{
// 模拟第一个网络请求requestA，4s后返回
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(4 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 执行requestA请求完成后的taskA
});
});
dispatch_async(requestQueue, ^{
// 模拟第一个网络请求requestB，2s后返回
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 执行requestB请求完成后的taskB
});
});
dispatch_async(requestQueue, ^{
// 模拟第一个网络请求requestA，3s后返回
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 执行requestC请求完成后的taskC
});
});
2. 保证顺序执行回调
为了能顺序执行回调方法，我想到了串行队列，如果我把blockA/B/C都丢到一个串行队列中，那么就可以保证回调处理是顺序执行的了，所以有了下面的代码：
dispatch_queue_t blockQueue = dispatch_queue_create("com.blockQueue", DISPATCH_QUEUE_SERIAL);
dispatch_sync(blockQueue, ^{
[self taskA];
});
dispatch_sync(blockQueue, ^{
[self taskB];
});
dispatch_sync(blockQueue, ^{
[self taskC];
});
我将请求后需要执行的task预先加入到了一个串行队列中。
3. 控制启动的时机
任何一个task的执行都有两个条件约束：
- 已执行优先级更高的
task； -
task本身对应的request已请求完成；
既然串行队列保证了第1点：我们的执行顺序，我们在加上第二点约束即可。
我选择了使用信号量来通知请求是否完成，并能够使未完成的请求所对应的task保持等待状态！简直完美。
创建了3个信号量的实例
初始化信号量为0。
@property (nonatomic, strong) dispatch_semaphore_t semaA;
@property (nonatomic, strong) dispatch_semaphore_t semaB;
@property (nonatomic, strong) dispatch_semaphore_t semaC;
修改上面虚拟网络请求的代码
- (void)viewDidLoad {
[super viewDidLoad];
dispatch_queue_t requestQueue = dispatch_queue_create("com.requestQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(requestQueue, ^{
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(4 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 通过信号量通知
// 执行requestA请求完成后的TaskA
dispatch_semaphore_signal(self.semaA);
});
});
dispatch_async(requestQueue, ^{
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
dispatch_semaphore_signal(self.semaB);
});
});
dispatch_async(requestQueue, ^{
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
dispatch_semaphore_signal(self.semaC);
});
});
// 这里注意一下!
// 如果不新建一个线程，而直接将上方的 `保证顺序执行回调` 代码放在这里
// 串行队列会将自己队列中的任务放在主线程中执行，从而造成主线程阻塞（假死状态）
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(taskQueue) object:nil];
[thread start];
}
- (void)taskQueue {
/ *
这里注释掉是因为有同学提示：在我们新建的线程中直接调用taskA/B/C，效果一样，
想了一下，确实如此！作以修改
dispatch_queue_t taskQueue = dispatch_queue_create("com. taskQueue", DISPATCH_QUEUE_SERIAL);
dispatch_sync(taskQueue, ^{
[self taskA];
});
dispatch_sync(taskQueue, ^{
[self taskB];
});
dispatch_sync(taskQueue, ^{
[self taskC];
});
*/
[self taskA];
[self taskB];
[self taskC];
}
另附上- taskA/B/C的代码，在等待信号量后，打印很简单的一段log日志：
- (void)taskA {
// NSLog(@"%@", [NSThread currentThread]);
dispatch_semaphore_wait(self.semaA, DISPATCH_TIME_FOREVER);
NSLog(@"A Done");
}
- (void)taskB {
dispatch_semaphore_wait(self.semaB, DISPATCH_TIME_FOREVER);
NSLog(@"B Done");
}
- (void)taskC {
dispatch_semaphore_wait(self.semaC, DISPATCH_TIME_FOREVER);
NSLog(@"C Done");
}
至此，就完成了设想场景的解决方案，有同学想到更好的解决方案，恳请不吝赐教！
最后想感谢一下 @诗雨 在群里的点拨，URLSession的方案由于自己对这方面的知识不熟悉，日后学习完成再做补充哈哈哈。
