GCD与多个网络请求的battle

在开发中，经常会碰到这样的情况：
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时，其所处线程自动执行其后语句。