说在前面
GCD是啥大家都懂，毕竟也不是iOS小白了，就不多做介绍，说一下为什么要写这篇文章吧。最近公司要招一个iOS开发，我就充当了一把临时面试官面试了几个iOS。当我问到面试者怎么处理多个请求完成后的一系列操作时，有的说造一个临时变量的做追加，其实这样可以，也算是信号量的基本逻辑，有的说用线程做延时操作，怎么延时，怎么操作说的不清楚，有少部分会提到GCD信号量，但是可能说不出来怎么操作，通过信号量的增加与递减，进行网络的并发请求，最后再做网络请求完成后的最终处理；其实实际上大家在做的时候，在网上一搜，基本都能找到；
GCD信号量的应用场景，一般是控制最大并发量，控制资源的同步访问，如数据访问，网络同步加载等。
需求1：多个网络请求完成后（无序）执行下一步
先看下如果不用GCD线程组或信号量会怎么执行
<pre style="margin: 0px; padding: 0px; white-space: pre-wrap; overflow-wrap: break-word; font-family: "Courier New" !important; font-size: 12px !important;">- (void)dispatchSyncSignal{
NSString *urlString = @"http://www.baidu.com";
NSURL *url = [NSURL URLWithString:urlString];
NSURLRequest *request = [NSURLRequest requestWithURL:url];
NSURLSession *session = [NSURLSession sharedSession]; for (int i=0; i<5; i++) {
NSURLSessionDataTask *task = [session dataTaskWithRequest:request completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
NSLog(@"请求回调 %d---%d",i,i);
}];
[task resume];
}
NSLog(@"end");
}</pre>
运行后后台打印输出：
从上面两次打印结果看出，end 先执行，由于网络请求的异步回调，然后各个网络请求的回调顺序是无序的。下面针对需求进行操作；
使用GCD的线程组 dispatch_group_t
<pre style="margin: 0px; padding: 0px; white-space: pre-wrap; overflow-wrap: break-word; font-family: "Courier New" !important; font-size: 12px !important;">- (void)dispatchSyncSignal1{ //创建线程组
dispatch_group_t group = dispatch_group_create();
NSString *urlString = @"http://www.baidu.com";
NSURL *url = [NSURL URLWithString:urlString];
NSURLRequest *request = [NSURLRequest requestWithURL:url];
NSURLSession *session = [NSURLSession sharedSession]; for (int i=0; i<5; i++) {
dispatch_group_enter(group);
NSURLSessionDataTask *task = [session dataTaskWithRequest:request completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
NSLog(@"请求回调 %d---%d",i,i);
dispatch_group_leave(group);
}];
[task resume];
}
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"end");
});
}</pre>
运行后后台打印输出：
从两次打印输出结果可以看出，end 是在所有网络请求之后才输出，符合了我们的需求。然后说下用到的相关方法：
dispatch_group_create(); 创建一个dispatch_group_t；
dispatch_group_enter(); 每次网络请求前调用；
dispatch_group_leave(); 每次网络请求后调用；
dispatch_group_enter(); 和 dispatch_group_leave(); 必须配合使用，有几次enter就要有几次leave；
然后当所有dispatch_group_enter(); 的 block 都 dispatch_group_leave(); 后，会执行dispatch_group_notify的block。
使用GCD的信号量 semaphore_t
<pre style="margin: 0px; padding: 0px; white-space: pre-wrap; overflow-wrap: break-word; font-family: "Courier New" !important; font-size: 12px !important;">- (void)dispatchSyncSignal2{
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
NSString *urlString = @"http://www.baidu.com";
NSURL *url = [NSURL URLWithString:urlString];
NSURLRequest *request = [NSURLRequest requestWithURL:url];
NSURLSession *session = [NSURLSession sharedSession];
__block NSInteger count = 0; for (int i=0; i<5; i++) {
NSURLSessionDataTask *task = [session dataTaskWithRequest:request completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
NSLog(@"请求回调 %d---%d",i,i);
count = count + 1; if (count == 5) {
dispatch_semaphore_signal(semaphore);
count = 0;
}
}];
[task resume];
}
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"end");
});
}</pre>
运行后后台打印输出：
从两次打印输出结果可以看出，end 也是在所有网络请求之后才输出，也符合了我们的需求。然后说下用到的相关方法：
dispatch_semaphore 信号量如果计数为0，则等待。dispatch_semaphore_signal(semaphore)为计数+1，dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER)为设置等待时间，这里设置的等待时间是永远等待。对于以上代码通俗一点讲就是，开始为0，等待，等5个网络请求都完成了，计数+1，然后计数-1返回，程序继续执行，count变量，记录网络回调的次数，回调5次之后再发信号量，使后面程序继续运行。
需求2：多个网络请求完成后（按顺序）执行下一步
如果按照需求1的方式，让多个网络请求按顺序执行完后，再进行下一步操作，那又应该怎么执行，当然还可以用信号量来操作：
<pre style="margin: 0px; padding: 0px; white-space: pre-wrap; overflow-wrap: break-word; font-family: "Courier New" !important; font-size: 12px !important;">- (void)dispatchSignal3{
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
NSString *urlString = @"http://www.baidu.com";
NSURL *url = [NSURL URLWithString:urlString];
NSURLRequest *request = [NSURLRequest requestWithURL:url];
NSURLSession *session = [NSURLSession sharedSession]; for (int i=0; i<5; i++) {
NSURLSessionDataTask *task = [session dataTaskWithRequest:request completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
NSLog(@"请求回调 %d---%d",i,i);
dispatch_semaphore_signal(semaphore);
}];
[task resume];
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
}
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"end");
});
}</pre>
运行后后台打印输出：
从两次打印输出结果可以看出，所有网络请求按顺序依次执行，end 在所有请求完成后输出，符合了我们的需求。
方法中每一次遍历，都执行以下 dispatch_semaphore_wait()，这个时候线程会等待，阻塞当前线程，直到dispatch_semaphore_signal(sem)调用之后，再继续下一次遍历。
简单说说
信号量是用于多线程同步的，跟锁不一样的是，信号量不一定是锁定某一个资源，而是流程上的概念，比如：有A、B两个线程，B线程要等A线程完成某一任务以后再进行自己下面的步骤，这个任务 并不一定是锁定某一资源，其实还可以是进行一些计算或者数据处理之类；
下面再通过做一个基于 NSObject 的生产者、消费者的 XKGradeRoom 工作间，看下信号量的用法，我们可以给生产间定一个最大生产量（这里定2个），毕竟生产间也不能无限制的生产，通过生产者与消费者关系，合理的对生产间的产量进行把控，在产量达到最大产量时，就停止生产，等待消费者消费。
XKGradeRoom.h
<pre style="margin: 0px; padding: 0px; white-space: pre-wrap; overflow-wrap: break-word; font-family: "Courier New" !important; font-size: 12px !important;">#import <Foundation/Foundation.h>
/**
生产消费工作间 */
@interface XKGradeRoom : NSObject /**
生产 */
- (void)xk_produce:(NSString *)sp; /**
消费
@return NSString */
- (NSString*)xk_comsumer; @end</pre>
XKGradeRoom.m
<pre style="margin: 0px; padding: 0px; white-space: pre-wrap; overflow-wrap: break-word; font-family: "Courier New" !important; font-size: 12px !important;">#import "XKGradeRoom.h"
@interface XKGradeRoom() /**
仓库 */ @property(strong,nonatomic) NSMutableArray* baseArray; /**
访问仓库（临界区）的互斥访问信号量 */ @property(strong,nonatomic) dispatch_semaphore_t criticalSemaphore; /**
消费者-是否消费仓库对象的标记 */ @property(strong,nonatomic) dispatch_semaphore_t comsumerSemaphore; /**
生产者-是否生产对象的标记 */ @property(strong,nonatomic) dispatch_semaphore_t productSemaphore; /**
仓库装载最大量 */ @property(nonatomic,assign) int maxProductCount; @end
@implementation XKGradeRoom - (instancetype)init{
self = [super init]; if (self) {
[self setup];
} return self;
} - (void)setup{
_maxProductCount = 2;
self.baseArray = [NSMutableArray array];
self.productSemaphore = dispatch_semaphore_create(_maxProductCount);
self.comsumerSemaphore = dispatch_semaphore_create(0); //初始化临界区互斥访问信号量,用信号量实现互斥,特殊初始值为1. //控制同一时刻只有一个线程对象在访问仓库
self.criticalSemaphore = dispatch_semaphore_create(1);
} /**
生产 */
-(void)xk_produce:(NSString *)sp{ //先获取访问仓库的信号量
long baseCount = dispatch_semaphore_wait(self.criticalSemaphore, 5 * NSEC_PER_SEC); if(baseCount != 0){
NSLog(@"仓库有人正在使用，生产者处于等待");
}else{ //再判断 仓库是否还有可放物品的空间
long maxSpaceCount = dispatch_semaphore_wait(self.productSemaphore, 5 * NSEC_PER_SEC); if(maxSpaceCount != 0){
NSLog(@"仓库%d个空间已经使用完，生产者处于等待：仓库容量:%lu",_maxProductCount,[self.baseArray count]); //生产完了释放临界区的访问锁
dispatch_semaphore_signal(self.criticalSemaphore);
}else{
[self.baseArray addObject:sp];
NSLog(@"新生产一个,仓库目前有：%lu",[self.baseArray count]);
dispatch_semaphore_signal(self.criticalSemaphore);
dispatch_semaphore_signal(self.comsumerSemaphore);
}
}
} /**
消费
@return NSString */
-(NSString*)xk_comsumer{
NSString* e = nil; long baseCount = dispatch_semaphore_wait(self.criticalSemaphore, 5 * NSEC_PER_SEC); //先获取访问仓库的信号量
if(baseCount != 0){
NSLog(@"仓库有人正在使用，消费者处于等待");
}else{ //再判断 仓库是否还有可取，如果有物品，则取一个出来，否则t等待
long avableCount = dispatch_semaphore_wait(self.comsumerSemaphore, 5 * NSEC_PER_SEC); if(avableCount != 0){
NSLog(@"空仓，消费者处于等待"); //生产完了释放临界区的访问锁
dispatch_semaphore_signal(self.criticalSemaphore);
}else{
e = [self.baseArray objectAtIndex:[self.baseArray count] -1];
[self.baseArray removeLastObject];
NSLog(@"消费了:%@ 仓库还有%lu:",e,[self.baseArray count]); //生产完了释放临界区的访问锁
dispatch_semaphore_signal(self.criticalSemaphore); //将仓库中的可放置的数量 +1
dispatch_semaphore_signal(self.productSemaphore);
}
} return e;
} @end</pre>
下面测试下这个工作间
<pre style="margin: 0px; padding: 0px; white-space: pre-wrap; overflow-wrap: break-word; font-family: "Courier New" !important; font-size: 12px !important;">XKGradeRoom * gradeRoom = [XKGradeRoom new]; //创建一个myDispatchQueue，主要是用于防止资源的竞争，一个线程处使用完资源，然后另外一个才能继续使用
dispatch_queue_t myDispatchQueue = dispatch_queue_create("com.example.gcd,myDispatchQueue", NULL);
dispatch_async(myDispatchQueue, ^{
[gradeRoom xk_produce:@"Queue1"];
NSLog(@"Queue1-执行完毕");
});
dispatch_async(myDispatchQueue, ^{
[gradeRoom xk_comsumer];
NSLog(@"Queue2-执行完毕");
});
dispatch_async(myDispatchQueue, ^{
[gradeRoom xk_comsumer];
NSLog(@"Queue3-执行完毕");
});
dispatch_async(myDispatchQueue, ^{
[gradeRoom xk_produce:@"Queue4"];
NSLog(@"Queue4-执行完毕");
});
dispatch_async(myDispatchQueue, ^{
[gradeRoom xk_produce:@"Queue5"];
NSLog(@"Queue5-执行完毕");
});
dispatch_async(myDispatchQueue, ^{
[gradeRoom xk_produce:@"Queue6"];
NSLog(@"Queue6-执行完毕");
});
dispatch_async(myDispatchQueue, ^{
[gradeRoom xk_comsumer];
[gradeRoom xk_comsumer];
[gradeRoom xk_comsumer];
[gradeRoom xk_comsumer];
NSLog(@"Queue7-执行完毕");
});</pre>
打印结果：
作为一个开发者，有一个学习的氛围跟一个交流圈子特别重要，这是一个我的iOS交流群：761407670 进群密码123，不管你是小白还是大牛欢迎入驻 ，分享BAT,阿里面试题、面试经验，讨论技术， 大家一起交流学习成长！
另附上一份大厂面试题，进群可自行下载！
image
作者：macro小K
出处：http://www.cnblogs.com/wangkejia/
网友评论