dispatch_semaphore网络应用

前段时间学习了一下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的执行都有两个条件约束：

1. 已执行优先级更高的task；
2. 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");
}

效果如下： gcd_1.png

至此，就完成了设想场景的解决方案，有同学想到更好的解决方案，恳请不吝赐教！

最后想感谢一下 @诗雨 在群里的点拨，URLSession的方案由于自己对这方面的知识不熟悉，日后学习完成再做补充哈哈哈。