发现自己是个懒人，当时注册，信誓旦旦的想着把平时总结的，用到的，解决的都记录下来，回头一看，平均一年写了不到一篇，技术水准也不是很高。惭愧惭愧。不过，什么内容网上都能搜罗出来一大堆，这篇文章，不讲内部实现（讲的话我也说不太好，需要的同学请自行soso），只讲直接可以使用的方式。
Dispatch_semaphore_t 信号量
GCD 信号量是一种异步转同步的方式，平时还可能用到的另外一个点，就是加锁。先说异步转同步，比如需求有ABC三个异步请求，但是由于业务需求，我们需要A ->B->C依次执行。信号量实现如下
{
//信号量初始化必须大于等于0， 因为dispatch_semaphore_wait 执行的是-1操作。
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
dispatch_queue_t queue = dispatch_queue_create("dispatch_barrier", DISPATCH_QUEUE_CONCURRENT);
//模仿异步请求
__block long x = 0;
dispatch_async(queue, ^{
[NSThread sleepForTimeInterval:3];
NSLog(@"============A");
x = dispatch_semaphore_signal(semaphore);//信号量 +1 进行了改变
NSLog(@"----- %ld",x);
});
NSLog(@"最先打印这里");
x = dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);//上面异步，此处信号量== 0，会进行等待操作
NSLog(@"----- %ld",x);
dispatch_async(queue, ^{
NSLog(@"============B");
dispatch_semaphore_signal(semaphore);
});
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
dispatch_async(queue, ^{
[NSThread sleepForTimeInterval:2];
NSLog(@"============C");
dispatch_semaphore_signal(semaphore);
});
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
NSLog(@"------ 执行结束了");
}
打印结果如下：
2019-08-29 15:25:39.308846+0800 DDDD[43496:3887181] 最先打印这里
2019-08-29 15:25:42.313244+0800 DDDD[43496:3887214] ============A
2019-08-29 15:25:42.313416+0800 DDDD[43496:3887214] ----- 1
2019-08-29 15:25:42.313422+0800 DDDD[43496:3887181] ----- 0
2019-08-29 15:25:42.313537+0800 DDDD[43496:3887216] ============B
2019-08-29 15:25:44.314613+0800 DDDD[43496:3887216] ============C
2019-08-29 15:25:44.314831+0800 DDDD[43496:3887181] ------ 执行结束了
信号量操作用于加锁，类似NSLock，使用起来更加方便，举例如下：
{
//初始化为1
dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
dispatch_queue_t queue = dispatch_queue_create("dispatch_barrier", DISPATCH_QUEUE_CONCURRENT);
for (int i = 0; i < 3 ; i ++) {
dispatch_async(queue, ^{
//这一步相当于加锁，初始化为1，此处-1操作后，会一直处于等待的状态
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
NSLog(@"--- 打印何时走到这里,加锁后，会一秒一走，未加锁的话，会连续打印10次");
//这里可以进行耗时操作
[NSThread sleepForTimeInterval:1];
NSLog(@"------- %d",i);
//解锁，继续进行for循环
dispatch_semaphore_signal(semaphore);
});
}
}
打印结果如下，如果注释掉加锁代码，打印如何，可以自己测试下
2019-08-29 15:47:06.486424+0800 DDDD[43708:3951203] --- 打印何时走到这里,加锁后，会一秒一走，未加锁的话，会连续打印10次
2019-08-29 15:47:07.490927+0800 DDDD[43708:3951203] ------- 0
2019-08-29 15:47:07.491189+0800 DDDD[43708:3951205] --- 打印何时走到这里,加锁后，会一秒一走，未加锁的话，会连续打印10次
2019-08-29 15:47:08.496292+0800 DDDD[43708:3951205] ------- 1
2019-08-29 15:47:08.496446+0800 DDDD[43708:3951204] --- 打印何时走到这里,加锁后，会一秒一走，未加锁的话，会连续打印10次
2019-08-29 15:47:09.500507+0800 DDDD[43708:3951204] ------- 2
Dispatch_group_t
dispatch_group_t 内部实现就是对dispatch_semaphore_t 的封装，dispatch_group_t 是一个初始值为LONG_MAX的信号量，dispatch_group_enter() 与 dispatch_semaphore_wait()相对应，dispatch_group_leave()与dispatch_semaphore_signal()相对应。dispatch_group判断是否任务完成的标准就是判断当前信号量的value是否回到了初始值。dispatch_group_enter()与dispatch_group_leave()可以嵌套使用，但必须成对出现。
开发中最常用的也就是多接口请求了。例如AB量个接口全部返回后再进行C操作，用信号量也可以实现，但信号量是一种同步操作，AB没有依赖关系的话，我们应该并发进行，此时信号量不能直接满足需求，dispatch_group_t就可以了。代码如下：
{
//创建一个并发的队列，是并发的，如果是串行的，则和使用信号量结果一致了
dispatch_queue_t queue = dispatch_queue_create("dispatch_group", DISPATCH_QUEUE_CONCURRENT);
dispatch_group_t group = dispatch_group_create();
dispatch_group_enter(group);
dispatch_group_async(group, queue, ^{
//模仿延时
[NSThread sleepForTimeInterval:5];
NSLog(@"============A");
dispatch_group_leave(group);
});
dispatch_group_enter(group);
dispatch_group_async(group, queue, ^{
NSLog(@"============B");
dispatch_group_leave(group);
});
dispatch_group_notify(group, queue, ^{
//开发过程中，渲染过程要放到主线程完成
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"============C");
});
});
}
打印结果如下，大家可以看到打印的时间差
2019-08-29 16:35:28.655795+0800 DDDD[44188:4059760] ============B
2019-08-29 16:35:33.659865+0800 DDDD[44188:4059758] ============A
2019-08-29 16:35:33.660073+0800 DDDD[44188:4059697] ============C
下面考虑个问题，如果我们需要再AB异步延时执行完之后，插入一个异步的D操作，然后再执行C呢？如果要满足AB并发，单纯的依赖dispatch_group_t是满足不了的。
Dispatch_barrier
- dispatch_barrier_async()
- dispatch_barrier_sync()
这是dispatch_barrier的两个方法，具体的区别，可以下下面的代码中体现，需求如上所说，在AB 之后进行D的操作，最后再进行C的操作。代码如下
{
//满足 AB并发，这里需要并发队列
dispatch_queue_t queue = dispatch_queue_create("dispatch_barrier", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
[NSThread sleepForTimeInterval:3];
NSLog(@"============A");
});
dispatch_async(queue, ^{
[NSThread sleepForTimeInterval:1];
NSLog(@"============B");
});
//dispatch_barrier_sync ---------
dispatch_barrier_async(queue, ^{
[NSThread sleepForTimeInterval:1];
NSLog(@"=我是 barrier 插入的======= D");
});
NSLog(@"---------1");
dispatch_async(queue, ^{
NSLog(@"============C");
});
NSLog(@"---------2");
}
打印结果如下（dispatch_barrier_async）
2019-08-29 16:22:03.890942+0800 DDDD[44060:4022500] ---------1
2019-08-29 16:22:03.891097+0800 DDDD[44060:4022500] ---------2
2019-08-29 16:22:04.894166+0800 DDDD[44060:4022525] ============B
2019-08-29 16:22:06.895921+0800 DDDD[44060:4022522] ============A
2019-08-29 16:22:07.900699+0800 DDDD[44060:4022522] =我是 barrier 插入的======= D
2019-08-29 16:22:07.900881+0800 DDDD[44060:4022522] ============C
如果替换为dispatch_barrier_sync,打印结果如下
2019-08-29 16:25:21.341990+0800 DDDD[44093:4032181] ============B
2019-08-29 16:25:23.342618+0800 DDDD[44093:4032180] ============A
2019-08-29 16:25:24.342861+0800 DDDD[44093:4032061] =我是 barrier 插入的======= D
2019-08-29 16:25:24.343021+0800 DDDD[44093:4032061] ---------1
2019-08-29 16:25:24.343134+0800 DDDD[44093:4032061] ---------2
2019-08-29 16:25:24.343144+0800 DDDD[44093:4032180] ============C
对比打印结果，我们可以知道，dispatch_barrier_async与dispatch_barrier_sync的区别就是dispatch_barrier_sync会阻断后面的任务插入队列或者阻断后面的任务执行，直到自己block块中的任务执行完成后，才会把后面的任务插入队列或者执行后面的操作。