iOS中信号量在网络请求中的使用

信号量介绍

信号量就是一个资源计数器，对信号量有两个操作来达到互斥，分别是P和V操作。我们平常说的加锁其实就是信号量为1时的特例。

信号量互斥访问的原理

设信号量值为n，当进程一运行时使用资源，进行P操作，即对信号量值-1，也就是资源数少了1个，这时信号量值为n-1。当线程一用完资源后，进行V操作，信号量+1。系统中规定当信号量值为0时，必须等待，直到信号量值大于0才能继续操作。假设当前信号量值为0，进程2想要使用资源，但是此时信号量为0，不能P操作，线程二便进入阻塞状态，直到它监测到信号量大于1时，才继续执行，即执行P操作，使信号量又变为0。
总结来说就是当信号量为0，便阻塞当前线程，信号量大于0，当前线程可正常执行。我们可以通过修改信号量来达到是否阻塞线程，继而控制线程同步的目的。

GCD中信号量的使用

在GCD中跟信号量有关的三个函数如下：

dispatch_semaphore_t sema = dispatch_semaphore_create(0); //创建一个semaphore
dispatch_semaphore_signal(sema);//发送一个信号
dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);//等待信号直到信号量大于0

signal相当于V操作，发送一个信号，即信号量+1；wait相当于P操作，信号量为0的话便一直阻塞，直到监测到信号量大于0，才继续往下执行。

多个网络请求都完成之后进行某操作

假设需求描述如下：一个页面存在多个网络请求，希望所有请求都结束之后才执行某操作。我们很容易想到队列组来实现这个功能，三下五除二便写出了如下代码：

dispatch_group_t group = dispatch_group_create();
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        //请求1
        NSLog(@"Request_1");
    });
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        //请求2
        NSLog(@"Request_2");
    });
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        //请求3
        NSLog(@"Request_3");
    });
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        //界面刷新
        NSLog(@"网络请求全部完成，刷新本页面");
    });

运行程序后，输出如下：

Request_2
Request_1
Request_3
网络请求全部完成，刷新本页面

看起来结果还不错，满足了我们的需求。但是仔细考虑一下，网络请求通常为异步操作，我们并不能确定请求什么时候会完成并进行回调。队列组的上述用法只能保证请求发出是按照我们所想的顺序，并不能保证请求完成后才执行最终操作（此处需要好好理解）。

接下来我们模拟网络请求来看看真实发生的事情。

// viewController.m
- (void)viewDidLoad {
    [super viewDidLoad];
    
    dispatch_group_t group = dispatch_group_create();
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        // 执行网络请求1
        [self request1];
    });
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        // 执行网络请求2
        [self request2];
    });
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        // 执行网络请求3
        [self request3];
    });
    dispatch_group_notify(group, dispatch_get_global_queue(0, 0), ^{
        NSLog(@"-------所有网络请求已请求完成-------");
    });
    
}

#pragma mark - ********************* private
- (void)request1 {
    /** 利用随机数和延迟函数模拟网络请求*/
    int random = arc4random() % 10;
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(random * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"网络请求一请求成功");
    });
}

- (void)request2 {
    /** 利用随机数和延迟函数模拟网络请求*/
    int random = arc4random() % 10;
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(random * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"网络请求二请求成功");
    });
}

- (void)request3 {
    /** 利用随机数和延迟函数模拟网络请求*/
    int random = arc4random() % 10;
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(random * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"网络请求三请求成功");
    });
}

输出如下：

-------所有网络请求已请求完成-------
网络请求三请求成功
网络请求二请求成功
网络请求一请求成功

可以看到，运行后马上接收到了线程组完成的提示，之后数据才依次请求下来，很明显三个单纯的AFNet请求已经不能满足我们的需求了。线程组完成时并没有在我们希望的时候给予通知。在真实开发中会造成的问题为多个请求均发送出去，但界面在还没有得到数据之前就刷新导致界面空白。

这个时候我们便可以利用信号量来完成我们的需求：

- (void)viewDidLoad {
    [super viewDidLoad];
    
    dispatch_group_t group = dispatch_group_create();
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        // 执行网络请求1
        [self request1];
        
    });
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        // 执行网络请求2
        [self request2];
        
    });
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        // 执行网络请求3
        [self request3];
        
    });
    dispatch_group_notify(group, dispatch_get_global_queue(0, 0), ^{
        NSLog(@"-------所有网络请求已请求完成-------");
    });
    
}

#pragma mark - ********************* private
- (void)request1 {
    /** 创建信号量并设置为0。信号量本质是资源数，为0表示资源被用完，需要等待，大于0表示可以直接使用*/
    dispatch_semaphore_t sema = dispatch_semaphore_create(0);
    
    /** 模拟网络请求*/
    int random = arc4random() % 10;
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(random * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        // 每次网络请求成功就让信号量+1，表示释放了一个当前资源，其他线程可以抢占了
        dispatch_semaphore_signal(sema);
        NSLog(@"网络请求一请求成功");
    });
    
    /** 如果信号量为0，表示没有资源可用，便一直等待，不再往下执行*/
    dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
}

- (void)request2 {
    /** 创建信号量并设置为0。信号量本质是资源数，为0表示资源被用完，需要等待，大于0表示可以直接使用*/
    dispatch_semaphore_t sema = dispatch_semaphore_create(0);
    
    /** 模拟网络请求*/
    int random = arc4random() % 10;
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(random * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        // 每次网络请求成功就让信号量+1，表示释放了一个当前资源，其他线程可以抢占了
        dispatch_semaphore_signal(sema);
        NSLog(@"网络请求二请求成功");
    });
    
    /** 如果信号量为0，表示没有资源可用，便一直等待，不再往下执行*/
    dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
}

- (void)request3 {
    /** 创建信号量并设置为0。信号量本质是资源数，为0表示资源被用完，需要等待，大于0表示可以直接使用*/
    dispatch_semaphore_t sema = dispatch_semaphore_create(0);
    
    /** 模拟网络请求*/
    int random = arc4random() % 10;
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(random * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        // 每次网络请求成功就让信号量+1，表示释放了一个当前资源，其他线程可以抢占了
        dispatch_semaphore_signal(sema);
        NSLog(@"网络请求三请求成功");
    });
    
    /** 如果信号量为0，表示没有资源可用，便一直等待，不再往下执行*/
    dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
}

再看运行结果：

2018-05-25 19:43:35.945983+0800 AFNetworking[34017:18893163] 网络请求三请求成功
2018-05-25 19:43:37.052914+0800 AFNetworking[34017:18893163] 网络请求二请求成功
2018-05-25 19:43:40.350873+0800 AFNetworking[34017:18893163] 网络请求一请求成功
2018-05-25 19:43:40.350901+0800 AFNetworking[34017:18893306] -------所有网络请求已请求完成-------

可以看到，我们的网络请求仍然是异步的，而且在所有网络请求完成之后才会刷新界面，实现了我们的需求。

注：这里有一个地方不好理解，为什么一开始要设置信号量为0呢？按照上面的说法，信号量为0不就一直卡住当前线程了么？其实这正是我们想要的效果，想象一下，当我们程序走到dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);这句代码时，因为信号量为0，所以当前线程阻塞不会继续往下执行，但是网络请求成功之后（在代码中是走了随机的几秒）会执行block块中的dispatch_semaphore_signal(sema);代码，使得信号量+1，而wait函数此时监测到信号量大于0 ，便继续往下执行。这样才能保证全部网络请求完成之后再进行最终操作。

网络请求间实现依赖关系

现在我们有一个新需求：三个任务分别为下载图片，打水印和上传图片，三个任务需异步执行但需要顺序性，即先下载图片，然后给图片打水印，然后才能上传。

//1.任务一：下载图片
    NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
        [self request_A];
    }];

    //2.任务二：打水印
    NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
        [self request_B];
    }];

    //3.任务三：上传图片
    NSBlockOperation *operation3 = [NSBlockOperation blockOperationWithBlock:^{
        [self request_C];
    }];

    //4.设置依赖
    [operation2 addDependency:operation1];      //任务二依赖任务一
    [operation3 addDependency:operation2];      //任务三依赖任务二

    //5.创建队列并加入任务
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    [queue addOperations:@[operation3, operation2, operation1] waitUntilFinished:NO];

同上面的例子一样，如果我们不对请求方法做处理，那么得到的结果将不会是我们想要的，如下所示：

---打水印---
---下载图片---
---上传图片---

接下来我们将请求方法修改为添加了信号量的形式，伪代码如下：

dispatch_semaphore_t sema = dispatch_semaphore_create(0);
[网络请求:{
        成功：dispatch_semaphore_signal(sema);
        失败：dispatch_semaphore_signal(sema);
}]
dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);

运行结果为：

---下载图片---
---打水印---
---上传图片---

其他方法

当然我们不一定必须使用信号量才能完成上述两个需求，还可以使用队列组的enter 和 leave或者在任务一的完成回调中再去执行任务二。其中队列组的enter和leave方法与信号量类似。
现在有一个需求是这样的，有10个网络请求，想让其异步执行，顺序回调。目前除了在回调里请求下一个请求的办法外我只发现一个方法可以做到，利用条件锁，代码如下：

- (void)viewDidLoad {
    [super viewDidLoad];
    
    _lock = [[NSConditionLock alloc] initWithCondition:0];
    dispatch_queue_t queue = dispatch_queue_create(nil, DISPATCH_QUEUE_CONCURRENT);
    for (int i=0; i<10; i++) {
        int random = arc4random() % 10;
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(random * NSEC_PER_SEC)), queue, ^{
            dispatch_async(queue, ^{
                [self.lock lockWhenCondition:i];
                NSLog(@"%d---%d",i,i);
                [self.lock unlockWithCondition:i+1];
            });
        });
    }
}