在开发中，经常会碰到这样的情况：
1.同一个页面上，有好几个网络请求，需要等到所有的网络请求都调用结束再进行下一步操作。
2.同一个页面上，有好几个网络请求，但第二个接口依赖于第一个接口，必须等到第二个调用完再调用。
处理上述问题的方式很多，可以在接口回调里再去调下一个接口；可以自己加变量来判断调用顺序。但其实GCD已经提供了很好的方法来解决这一问题，可以用dispatch_group_async和dispatch_semaphore_t来操作，具体看一下实例。
多个请求都结束再执行下一步
使用dispatch_group_async
//mainthread
dispatch_group_t group = dispatch_group_create();
NSLog(@"!-----1");
dispatch_group_enter(group);
[[NetworkMgr sharedMgr] refreshServerAppConfigWithCompleteHandle:^{//main thread block
NSLog(@"!-----2");
dispatch_group_leave(group);
}];
NSLog(@"!-----3");
dispatch_group_enter(group);
[[NetworkMgr sharedMgr] refreshBussinessRouterWithCompleteHandle:^{//main thread block
NSLog(@"!-----4");
dispatch_group_leave(group);
}];
NSLog(@"!-----5");
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"!-----6");
if (self.homeAction) {
self.homeAction(0, nil);
}
});
执行顺序
[37063:6826480] !-----1
[37063:6826480] !-----3
[37063:6826480] !-----5
[37063:6826480] !-----2
[37063:6826480] !-----4
[37063:6826480] !-----6
在执行每一个网络请求之前，先dispatch_group_enter，在请求回调时，再dispatch_group_leave，当两组请求都结束后，会自动触发dispatch_group_notify，实现self.homeAction在两个请求之后再调用。
使用dispatch_semaphore_t
NSLog(@"!-----1");
dispatch_semaphore_t semphore = dispatch_semaphore_create(0);
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
[[NetworkMgr sharedMgr] refreshServerAppConfigWithCompleteHandle:^{//main thread block
NSLog(@"!-----2");
dispatch_semaphore_signal(semphore);
}];
NSLog(@"!-----3");
[[NetworkMgr sharedMgr] refreshBussinessRouterWithCompleteHandle:^{//main thread block
NSLog(@"!-----4");
dispatch_semaphore_signal(semphore);
}];
NSLog(@"!-----5");
dispatch_async(queue, ^{
dispatch_semaphore_wait(semphore, DISPATCH_TIME_FOREVER);
dispatch_semaphore_wait(semphore, DISPATCH_TIME_FOREVER);
NSLog(@"!-----6");
if (self.homeAction) {
dispatch_async(dispatch_get_main_queue(), ^{
self.homeAction(0, nil);
});
}
});
执行顺序
[36999:6817621] !-----1
[36999:6817621] !-----3
[36999:6817621] !-----5
[36999:6817621] !-----2
[36999:6817621] !-----4
[36999:6817985] !-----6
也能够实现在两个网络回调结束之后，再执行self.homeAction。刚开始的信号量为0，在创建的queue中，两个请求都没返回的情况下，会等在第一个dispatch_semaphore_wait。当第一个请求结束后，发出dispatch_semaphore_signal，这时跳过第一个dispatch_semaphore_wait。第二个请求结束后，发出dispatch_semaphore_signal，跳过第二个dispatch_semaphore_wait。这样就实现了在两个网络回调结束之后，再执行self.homeAction。
不过需要注意的是，dispatch_semaphore_wait会使当前线程等待。就上述代码而言，dispatch_semaphore_wait所在的线程是子线程，而网络回调的线程是在主线程，当调用到dispatch_semaphore_wait会使子线程发生等待，知道接收到主线程的两个dispatch_semaphore_signal，等待才会取消。如果把queue改成主线程，就会阻塞，因为主线程会一直等待，请求回调的block也是在主线程，永远不会执行。
多个请求按顺序同步执行
使用dispatch_semaphore_t
dispatch_semaphore_t semphore = dispatch_semaphore_create(0);
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
dispatch_async(queue, ^{
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
[[NetworkMgr sharedMgr] refreshServerAppConfigWithCompleteHandle:^{//main thread block
NSLog(@"!-----1");
dispatch_semaphore_signal(semphore);
}];
});
});
dispatch_async(queue, ^{
dispatch_semaphore_wait(semphore, DISPATCH_TIME_FOREVER);
[[NetworkMgr sharedMgr] refreshBussinessRouterWithCompleteHandle:^{//main thread block
NSLog(@"!-----2");
dispatch_semaphore_signal(semphore);
}];
});
dispatch_async(queue, ^{
dispatch_semaphore_wait(semphore, DISPATCH_TIME_FOREVER);
NSLog(@"!-----3");
if (self.homeAction) {
dispatch_async(dispatch_get_main_queue(), ^{
self.homeAction(0, nil);
});
}
});
执行顺序
[37297:6848505] !-----1
[37297:6848505] !-----2
[37297:6848808] !-----3
打印结束显示，保证了第二个请求回调在第一个之后。刚开始创建的信号量为1，执行第一个请求，回调结束后，发出dispatch_semaphore_signal，才会执行第二个请求，回调结束后才会执行self.homeAction。
这里也是要保证dispatch_semaphore_wait所在的线程必须和dispatch_semaphore_signal所在的线程不同。
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_signal的返回值为long类型，当返回值为0时表示当前并没有线程等待其处理的信号量，其处理
的信号量的值加1即可。当返回值不为0时，表示其当前有（一个或多个）线程等待其处理的信号量，并且该函数唤醒了一
个等待的线程（当线程有优先级时，唤醒优先级最高的线程；否则随机唤醒）。
dispatch_semaphore_wait的返回值也为long型。当其返回0时表示在timeout之前，该函数所处的线程被成功唤醒。
当其返回不为0时，表示timeout发生。
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时，其所处线程自动执行其后语句。