多个网络请求并发执行、顺序执行

清疚 2023-10-10 09:08 46阅读 0赞

我们在开发中可能会遇到多个网络请求的需求，比如一个界面有两个请求，tableView的数据源及表头，需要等两个请求都完成才刷新UI，或者第二个的网络请求依赖第一个网络请求返回的数据，今天主要讲下两种方式的实现方式，当然也有其他方式，主要记录下我工作中使用的

#### 并发执行 ####

多个网络请求同时执行，等所有网络请求完成，再统一做其他操作，你可能会想到`dispatch_group_async`、`dispatch_group_notify`结合使用，如下：

1 dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
     2     dispatch_group_t group = dispatch_group_create();
     3     dispatch_group_async(group, queue, ^{
     4         NSLog(@"任务一完成");
     5     });
     6 
     7     dispatch_group_async(group, queue, ^{
     8         NSLog(@"任务二完成");
     9     });
    10 
    11     dispatch_group_async(group, queue, ^{
    12         NSLog(@"任务三完成");
    13     });
    14     //在分组的所有任务完成后触发
    15     dispatch_group_notify(group, queue, ^{
    16         NSLog(@"所有任务完成");
    17     });

打印结果：

1 2017-02-17 09:26:18.668 信号量[53171:2916114] 任务二完成
    2 2017-02-17 09:26:18.668 信号量[53171:2916133] 任务三完成
    3 2017-02-17 09:26:18.668 信号量[53171:2916117] 任务一完成
    4 2017-02-17 09:26:18.669 信号量[53171:2916117] 所有任务完成

由于三个任务都是异步的，所有返回结果顺序不一定是正序，看似却确实实现了我们的需求，但是网络请求是异步的，耗时的，不是马上就能返回结果的，如下使用`dispatch_after`模拟网络请求的延迟：

1 dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
     2     dispatch_group_t group = dispatch_group_create();
     3     dispatch_group_async(group, queue, ^{
     4         dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
     5             NSLog(@"请求一");
     6         });
     7     });
     8 
     9     dispatch_group_async(group, queue, ^{
    10         NSLog(@"任务二完成");
    11     });
    12 
    13     dispatch_group_async(group, queue, ^{
    14         NSLog(@"任务三完成");
    15     });
    16     //在分组的所有任务完成后触发
    17     dispatch_group_notify(group, queue, ^{
    18         NSLog(@"所有任务完成");
    19     });

打印结果：

1 2017-02-17 09:30:49.263 信号量[53528:2935734] 任务二完成
    2 2017-02-17 09:30:49.263 信号量[53528:2935737] 任务三完成
    3 2017-02-17 09:30:49.263 信号量[53528:2935737] 所有任务完成
    4 2017-02-17 09:30:50.340 信号量[53528:2935638] 请求一

可看到任务一的延迟请求完成造成了一些问题，这时候我们可以用信号量即`dispatch_semaphore`，包括三个部分：`dispatch_semaphore_create()`、`dispatch_semaphore_signal()`、`dispatch_semaphore_wait()`,三个结合使用，各个参数解释一下：

>  *  `dispatch_semaphore_create`：`dispatch_semaphore_t dispatch_semaphore_create(long value)`;传入的参数为`long`类型，输出一个`dispatch_semaphore_t`类型且值为`value`的信号量。值得注意的是，这里的传入的参数value必须`大于或等于0`，否则`dispatch_semaphore_create`会返回`NULL`。
>  *  `dispatch_semaphore_signal`的声明为`long` `dispatch_semaphore_signal(dispatch_semaphore_t dsema)`，这个函数会使传入的信号量`dsema`的值`加1`；
>  *  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`时，其所处线程自动执行其后语句。
>  *  `dispatch_semaphore_signal`的返回值为`long`类型，当返回值`为0`时表示当前并没有线程等待其处理的信号量，其处理的信号量的值`加1`即可。当返回值`不为0`时，表示其当前有（一个或多个）线程等待其处理的信号量，并且该函数唤醒了一个等待的线程（当线程有优先级时，唤醒优先级最高的线程；否则随机唤醒）。`dispatch_semaphore_wait`的返回值也为`long`型。当其返回`0`时表示`在timeout`之前，该函数所处的线程被成功唤醒。当其返回`不为0`时，表示`timeout`发生。
>  *  在设置`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`的时间。
>  *  关于信号量，一般可以用停车来比喻：  
>     停车场剩余4个车位，那么即使同时来了四辆车也能停的下。如果此时来了五辆车，那么就有一辆需要等待。信号量的值就相当于剩余车位的数目，`dispatch_semaphore_wait`函数就相当于来了一辆车，`dispatch_semaphore_signal`就相当于走了一辆车。停车位的剩余数目在初始化的时候就已经指明了（`dispatch_semaphore_create（long value）`），调用一次`dispatch_semaphore_signal`，剩余的车位就增加一个；调用一次`dispatch_semaphore_wait`剩余车位就减少一个；当剩余车位为0时，再来车（即调用`dispatch_semaphore_wait`）就只能等待。有可能同时有几辆车等待一个停车位。有些车主没有耐心，给自己设定了一段等待时间，这段时间内等不到停车位就走了，如果等到了就开进去停车。而有些车主就像把车停在这，所以就一直等下去。

代码示例：

1 dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
     2     dispatch_group_t group = dispatch_group_create();
     3     dispatch_semaphore_t sem = dispatch_semaphore_create(0);
     4     dispatch_group_async(group, queue, ^{
     5         dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
     6             dispatch_semaphore_signal(sem);
     7             NSLog(@"请求一");
     8         });
     9         dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
    10     });
    11     dispatch_group_async(group, queue, ^{
    12         dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.8 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    13             dispatch_semaphore_signal(sem);
    14             NSLog(@"请求二");
    15         });
    16         dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
    17     });
    18 
    19     dispatch_group_async(group, queue, ^{
    20         NSLog(@"请求三");
    21 
    22     });
    23     //在分组的所有任务完成后触发
    24     dispatch_group_notify(group, queue, ^{
    25 
    26         NSLog(@"请求完成");
    27     });

打印结果：

1 2017-02-17 09:47:58.084 信号量[54431:3002639] 请求三
    2 2017-02-17 09:47:58.958 信号量[54431:3002590] 请求二
    3 2017-02-17 09:47:59.177 信号量[54431:3002590] 请求一
    4 2017-02-17 09:47:59.177 信号量[54431:3002636] 请求完成

就实现了我们的需求(多个网络请求都完成再做其他操作),当然也可以通过`dispatch_group_enter、dispatch_group_leave`结合实现，使用`dispatch_group_enter()`函数进入到任务组中，然后异步执行队列中的任务，最后使用`dispatch_group_leave()`函数离开任务组即可，

1 dispatch_group_t group = dispatch_group_create();
     2     dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
     3 
     4     dispatch_group_enter(group);
     5     dispatch_group_async(group, queue, ^{
     6         dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
     7             NSLog(@"任务1");
     8             dispatch_group_leave(group);
     9         });
    10     });
    11 
    12     dispatch_group_enter(group);
    13     dispatch_group_async(group, queue, ^{
    14         NSLog(@"任务2");
    15         dispatch_group_leave(group);
    16     });
    17 
    18     dispatch_group_enter(group);
    19     dispatch_group_async(group, queue, ^{
    20         NSLog(@"任务3");
    21         dispatch_group_leave(group);
    22     });
    23 
    24     dispatch_group_notify(group, queue, ^{
    25         NSLog(@"完成");
    26     });

打印结果：

1 2017-02-17 09:56:13.129 信号量[54888:3036359] 任务2
    2 2017-02-17 09:56:13.129 信号量[54888:3036359] 任务3
    3 2017-02-17 09:56:14.222 信号量[54888:3036264] 任务1
    4 2017-02-17 09:56:14.222 信号量[54888:3036359] 完成

同样实现了我们需求

#### 顺序执行 ####

仍然通过信号量执行，执行任务一，将信号量`dispatch_semaphore_wait`减一，请求完成，再`dispatch_semaphore_signal`加一，一次类推，代码实现

1 dispatch_semaphore_t sem = dispatch_semaphore_create(1);
     2     dispatch_queue_t queue = dispatch_queue_create("testBlock", NULL);
     3     dispatch_async(queue, ^{
     4         dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
     5         dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
     6             NSLog(@"1");
     7             dispatch_semaphore_signal(sem);
     8 
     9         });
    10     });
    11     dispatch_async(queue, ^{
    12         dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
    13         NSLog(@"2");
    14         dispatch_semaphore_signal(sem);
    15     });
    16     dispatch_async(queue, ^{
    17         dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
    18         dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    19             NSLog(@"3");
    20             dispatch_semaphore_signal(sem);
    21 
    22         });
    23     });
    24     dispatch_async(queue, ^{
    25         dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
    26         NSLog(@"4");
    27         dispatch_semaphore_signal(sem);
    28 
    29     });

打印结果：

1 2017-02-17 09:57:54.058 信号量[54991:3043275] 1
    2 2017-02-17 09:57:54.059 信号量[54991:3043355] 2
    3 2017-02-17 09:57:57.358 信号量[54991:3043275] 3
    4 2017-02-17 09:57:57.358 信号量[54991:3043355] 4

[这篇文章][Link 1]对信号量做了详细介绍  
参考：  
[关于dispatch\_semaphore的使用][dispatch_semaphore]

作者：夜晚看日出  
链接：http://www.jianshu.com/p/56313152e87e  
來源：简书  
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

转载于:https://www.cnblogs.com/SUPER-F/p/7365764.html

[Link 1]: http://www.jianshu.com/p/f191383473ba
[dispatch_semaphore]: http://www.cnblogs.com/snailHL/p/3906112.html