iOS-GCD使用dispatch_semaphore_t处理线

【前言】

假设系统有空闲资源，可以利用。同一时间有三个线程想要进行访问，这种情况下该如何处理呢?
比如我们想批量下载图片，并发异步执行，则每个下载都会开辟一个新的县城，如果太多CPU会吃不消，那么我们可以利用信号量来控制一下最大开辟线程数。

【含义】

信号量：就是一种可用来控制访问资源的数量的标识，设定了一个信号量，在线程访问之前，加上信号量的处理，则可告知系统按照我们指定的信号量数量来执行多个线程。

其实，这有点类似锁机制了，只不过信号量都是系统帮助我们处理了，我们只需要在执行线程之前，设定一个信号量值，并且在使用时，加上信号量处理方法就行了。

【使用】

主要有3个函数：

// 创建信号量，参数：信号量的初值，表示最多几个资源可访问。
dispatch_semaphore_create（信号量值）
//等待信号量
dispatch_semaphore_wait（信号量，等待时间）
//发送信号量
dispatch_semaphore_signal(信号量)

1、执行dispatch_semaphore_create 会根据传入的long型参数创建对应数目的信号量；
2、执行dispatch_semaphore_signal 会增加一个信号量；
3、执行dispatch_semaphore_wait 则会减少一个信号量
4、正常的使用顺序是先wait然后再signal，这两个函数通常成对使用。　
5、如果信号量是0，就会根据传入的等待时间来等待。

这里使用sleep()方法来模拟异步操作执行时间。代码示例如下：

- (void)viewDidLoad {
    [super viewDidLoad];
  
    [self semaphoreTaskTest]; 
}
/** 信号量测试 */
- (void)semaphoreTaskTest{
   
    //crate的value表示，最多几个资源可访问。
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(2);
    dispatch_queue_t quene = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
   //任务A
   dispatch_async(quene, ^{
       dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
       NSLog(@"任务A准备开始 - 1");
       sleep(3);
       NSLog(@"任务A执行结束 - 1");
       dispatch_semaphore_signal(semaphore);
   });
   //任务B
   dispatch_async(quene, ^{
       dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
       NSLog(@"任务B准备开始 - 2");
       sleep(2);
       NSLog(@"任B执行结束 - 2");
       dispatch_semaphore_signal(semaphore);
   });
   //任务c
   dispatch_async(quene, ^{
       dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
       NSLog(@"任务C准备开始 - 3");
       sleep(4);
       NSLog(@"任C执行结束 - 3");
       dispatch_semaphore_signal(semaphore);
   });
}

执行结果：

2020-08-13 11:20:44.081980+0800 CZProjectTestDemo[7981:1268555] 任务A准备开始 - 1
2020-08-13 11:20:44.082086+0800 CZProjectTestDemo[7981:1268552] 任务B准备开始 - 2
2020-08-13 11:20:46.087317+0800 CZProjectTestDemo[7981:1268552] 任B执行结束 - 2
2020-08-13 11:20:46.087686+0800 CZProjectTestDemo[7981:1268550] 任务C准备开始 - 3
2020-08-13 11:20:47.087321+0800 CZProjectTestDemo[7981:1268555] 任务A执行结束 - 1
2020-08-13 11:20:50.093025+0800 CZProjectTestDemo[7981:1268550] 任C执行结束 - 3

总结：由于设定的信号值为2，先执行两个线程。等执行完一个，才会继续执行下一个，保证同一时间执行的线程数不超过2，由于任务A执行时间是4秒，任务B执行时间是2秒，所以任务B先于A完成。

这里我们扩展一下，假设我们设定信号值=1，修改上面代码

    dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);

执行结果：

2020-08-13 11:24:30.656495+0800 CZProjectTestDemo[8026:1269817] 任务A准备开始 - 1
2020-08-13 11:24:33.661692+0800 CZProjectTestDemo[8026:1269817] 任务A执行结束 - 1
2020-08-13 11:24:33.662102+0800 CZProjectTestDemo[8026:1269816] 任务B准备开始 - 2
2020-08-13 11:24:35.667413+0800 CZProjectTestDemo[8026:1269816] 任B执行结束 - 2
2020-08-13 11:24:35.667938+0800 CZProjectTestDemo[8026:1269813] 任务C准备开始 - 3
2020-08-13 11:24:39.673319+0800 CZProjectTestDemo[8026:1269813] 任C执行结束 - 3

如果信号值=1，则任务会依次执行。

如果设定信号值=3

    dispatch_semaphore_t semaphore = dispatch_semaphore_create(3);

执行结果：

2020-08-13 11:25:34.837949+0800 CZProjectTestDemo[8067:1270430] 任务A准备开始 - 1
2020-08-13 11:25:34.838045+0800 CZProjectTestDemo[8067:1270434] 任务B准备开始 - 2
2020-08-13 11:25:34.838104+0800 CZProjectTestDemo[8067:1270436] 任务C准备开始 - 3
2020-08-13 11:25:36.843300+0800 CZProjectTestDemo[8067:1270434] 任B执行结束 - 2
2020-08-13 11:25:37.843243+0800 CZProjectTestDemo[8067:1270430] 任务A执行结束 - 1
2020-08-13 11:25:38.843313+0800 CZProjectTestDemo[8067:1270436] 任C执行结束 - 3

【项目实战】

假设我们有这样一个需求：
有多个网络请求AB，现在要实现的是:A 请求数据成功之后,再执行 B 的网络请求

一个很容易想到的做法就是：

- (void)getToken{
    //以上请求的设置忽略
    NSURLSessionDataTask *task = [mySession dataTaskWithRequest:request completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
        if (data) {
            NSLog(@"get Token");
            //拿到token，传给request请求做参数
            [self request:token];
        }else{
            NSLog(@"token error:%@",error.description);
        } 
    }];
    [task resume];
}

- (void)request:(NSString *)params{
    //请求的设置忽略
    NSURLSessionDataTask *task = [mySession dataTaskWithRequest:request completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
        if (data) {
            NSLog(@"request success");
        }else{
            NSLog(@"request error:%@----",error.description);
        }
    }];
    [task resume];
}

这种做法是最容易想到的，但是缺点也是很明显的。两个方法的业务层的请求紧密混合在一起了，不容易分离，这会导致你的网络管理类的请求方法变得臃肿。
所以，下面我要用信号量使得业务层完成分离开，使代码逻辑更清晰。

代码示例

- (void)viewDidLoad {
    [super viewDidLoad];
  
    [self semaphoreTaskTest]; 
}
/** 信号量测试 */
- (void)semaphoreTaskTest{
   
    // crate的value表示，最多几个资源可访问。
    // 这里设定的信号值为1，这样每次仅开辟一个线程空间来处理任务，无论任务耗时长短，保证一个执行完成之后再去执行另一个。
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
    dispatch_queue_t quene = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
   //任务A
   dispatch_async(quene, ^{
       dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
       NSLog(@"任务A准备开始 - 1");
       sleep(3);
       NSLog(@"任务A执行结束 - 1");
       dispatch_semaphore_signal(semaphore);
   });
   //任务B
   dispatch_async(quene, ^{
       dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
       NSLog(@"任务B准备开始 - 2");
       sleep(2);
       NSLog(@"任B执行结束 - 2");
       dispatch_semaphore_signal(semaphore);
   });
   //任务c
   dispatch_async(quene, ^{
       dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
       NSLog(@"任务C准备开始 - 3");
       sleep(4);
       NSLog(@"任C执行结束 - 3");
       dispatch_semaphore_signal(semaphore);
   });
}

结果打印如下

2020-08-13 11:24:30.656495+0800 CZProjectTestDemo[8026:1269817] 任务A准备开始 - 1
2020-08-13 11:24:33.661692+0800 CZProjectTestDemo[8026:1269817] 任务A执行结束 - 1
2020-08-13 11:24:33.662102+0800 CZProjectTestDemo[8026:1269816] 任务B准备开始 - 2
2020-08-13 11:24:35.667413+0800 CZProjectTestDemo[8026:1269816] 任B执行结束 - 2
2020-08-13 11:24:35.667938+0800 CZProjectTestDemo[8026:1269813] 任务C准备开始 - 3
2020-08-13 11:24:39.673319+0800 CZProjectTestDemo[8026:1269813] 任C执行结束 - 3

dispatch_group_wait ()：让线程等待任务A执行完成之后再执行任务B。
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);// 任务A,B同时执行完才会执行下面的任务C,根据需求可以不需要。