GCD的信号量的使用及其原理
什么是信号量
信号量（semaphore）是操作系统用来解决并发中的互斥和同步问题的一种方法。
信号量对于允许多个线程并发访问的资源，它是一个很好的选择。一个初始值为N的信号量允许N个线程并发访问。线程访问资源时首先获取信号量，进行如下操作：
将信号量的值减1。如果信号量的值小于0，则进入等待状态，否则继续执行。访问资源之后，线程释放信号量，将信号量的值加1。如果信号量的值不小于1，唤醒一个等待中的线程。
信号量的使用
//初始化信号量，初始值N = 2，表示最多只允许两条线程同时获得信号量
dispatch_semaphore_t semaphore = dispatch_semaphore_create(2);
// 并发队列
dispatch_queue_t conQueue = dispatch_queue_create("com.hello-world.djx", DISPATCH_QUEUE_CONCURRENT);
for (int i = 1; i <= 5; i++) {
dispatch_async(conQueue, ^{
// 线程执行dispatch_semaphore_wait时，会获取当前信号量，将信号量值减一，如果信号量值小于0，则等待dispatch_semaphore_signal唤醒线程；如果信号量值大于或等于0则开始执行任务
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
NSLog(@"开始任务：%d", i);
sleep(i);
NSLog(@"结束任务：%d", i);
//线程执行完任务之后调用dispatch_semaphore_signal，将信号量值加一，如果此时信号量值大于0，说明没有等待的线程，直接返回，如果此时信号量值小于或等于0，表次此前信号量已用尽，可能有正等待的线程，这时候会试图唤起等待的线程
dispatch_semaphore_signal(semaphore);
});
}
打印结果：
2021-08-25 15:51:47.942058+0800 GCDDemo[31306:26034698] 开始任务：2
2021-08-25 15:51:47.942087+0800 GCDDemo[31306:26034700] 开始任务：1
2021-08-25 15:51:48.945177+0800 GCDDemo[31306:26034700] 结束任务：1
2021-08-25 15:51:48.945402+0800 GCDDemo[31306:26034699] 开始任务：4
2021-08-25 15:51:49.944143+0800 GCDDemo[31306:26034698] 结束任务：2
2021-08-25 15:51:49.944354+0800 GCDDemo[31306:26034697] 开始任务：3
2021-08-25 15:51:52.947185+0800 GCDDemo[31306:26034699] 结束任务：4
2021-08-25 15:51:52.947173+0800 GCDDemo[31306:26034697] 结束任务：3
2021-08-25 15:51:52.947391+0800 GCDDemo[31306:26034696] 开始任务：5
2021-08-25 15:51:57.947824+0800 GCDDemo[31306:26034696] 结束任务：5
可以看出只能同时执行两个任务，一个任务结束之后才能唤醒其他等待的线程继续执行。信号量在这里起到控制队列并发数的作用。其实这里的初始值如果改成1的话，信号量就相当于互斥锁的作用了。
信号量的底层原理
dispatch_semaphore_create源码解读
这是创建信号量并初始化信号量的函数，参数value就是信号量的值。
dispatch_semaphore_t
dispatch_semaphore_create(long value)
{
dispatch_semaphore_t dsema;
// If the internal value is negative, then the absolute of the value is
// equal to the number of waiting threads. Therefore it is bogus to
// initialize the semaphore with a negative value.
if (value < 0) {
return DISPATCH_BAD_INPUT;
}
dsema = _dispatch_object_alloc(DISPATCH_VTABLE(semaphore),
sizeof(struct dispatch_semaphore_s));
dsema->do_next = DISPATCH_OBJECT_LISTLESS;
dsema->do_targetq = _dispatch_get_default_queue(false);
dsema->dsema_value = value;
_dispatch_sema4_init(&dsema->dsema_sema, _DSEMA4_POLICY_FIFO);
dsema->dsema_orig = value;
return dsema;
}
DISPATCH_VTABLE这里可以获取到信号量的类信息，通过_dispatch_object_alloc创建一个信号量。value值被保留到属性dsema_value和dsema_orig中（为什么这里会有两个变量来接收value？请看后面的dispose方法），后面的调用的dispatch_semaphore_wait和dispatch_semaphore_signal都会对dsema_value进行操作。_dispatch_sema4_init初始化一个信号。
dispatch_semaphore_wait源码解读
long
dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout)
{
long value = os_atomic_dec2o(dsema, dsema_value, acquire);
if (likely(value >= 0)) {
return 0;
}
return _dispatch_semaphore_wait_slow(dsema, timeout);
}
os_atomic_dec2o：os_atomic_dec2o->os_atomic_sub2o->os_atomic_sub->_os_atomic_c11_op((p), (v), m, sub, -)->atomic_fetch_sub_explicit
这里通过函数os_atomic_dec2o，最终调用atomic_fetch_sub_explicit对value进行减1的原子操作，然后返回当前信号量value。判断如果value大于0，说当前线程可以正常访问，直接返回0表次正常；反之，线程会调用函数_dispatch_semaphore_wait_slow进入等待被唤醒。
static long
_dispatch_semaphore_wait_slow(dispatch_semaphore_t dsema,
dispatch_time_t timeout)
{
long orig;
_dispatch_sema4_create(&dsema->dsema_sema, _DSEMA4_POLICY_FIFO);
switch (timeout) {
default:
if (!_dispatch_sema4_timedwait(&dsema->dsema_sema, timeout)) {
break;
}
// Fall through and try to undo what the fast path did to
// dsema->dsema_value
case DISPATCH_TIME_NOW:
orig = dsema->dsema_value;
while (orig < 0) {
if (os_atomic_cmpxchgvw2o(dsema, dsema_value, orig, orig + 1,
&orig, relaxed)) {
return _DSEMA4_TIMEOUT();
}
}
// Another thread called semaphore_signal().
// Fall through and drain the wakeup.
case DISPATCH_TIME_FOREVER:
_dispatch_sema4_wait(&dsema->dsema_sema);
break;
}
return 0;
}
这时候会根据timeout参数设定的时间来处理。如果timeout传的是DISPATCH_TIME_NOW，则表示不等待，这时候会再次尝试获取信号量，如果信号量此时已然小于0，则返回超时提醒；如果传入的是DISPATCH_TIME_FOREVER，表示会一直等待被唤醒，这时候就调用函数_dispatch_sema4_wait进行等待；如果是给定的一段时间，走default逻辑，调用函数_dispatch_sema4_timedwait进入计时等待：
bool
_dispatch_sema4_timedwait(_dispatch_sema4_t *sema, dispatch_time_t timeout)
{
struct timespec _timeout;
int ret;
do {
uint64_t nsec = _dispatch_time_nanoseconds_since_epoch(timeout);
_timeout.tv_sec = (__typeof__(_timeout.tv_sec))(nsec / NSEC_PER_SEC);
_timeout.tv_nsec = (__typeof__(_timeout.tv_nsec))(nsec % NSEC_PER_SEC);
ret = sem_timedwait(sema, &_timeout);
} while (unlikely(ret == -1 && errno == EINTR));
if (ret == -1 && errno == ETIMEDOUT) {
return true;
}
DISPATCH_SEMAPHORE_VERIFY_RET(ret);
return false;
}
等线程被唤醒之后返回执行代码，否则知道时间耗尽返回超时提醒。
dispatch_semaphore_signal源码解读
long
dispatch_semaphore_signal(dispatch_semaphore_t dsema)
{
long value = os_atomic_inc2o(dsema, dsema_value, release);
if (likely(value > 0)) {
return 0;
}
if (unlikely(value == LONG_MIN)) {
DISPATCH_CLIENT_CRASH(value,
"Unbalanced call to dispatch_semaphore_signal()");
}
return _dispatch_semaphore_signal_slow(dsema);
}
os_atomic_inc2o：os_atomic_inc2o->os_atomic_add2o->os_atomic_add->_os_atomic_c11_op((p), (v), m, add, +)->atomic_fetch_add_explicit
通过函数os_atomic_inc2o释放资源（release），同时对信号量加1，然后返回加1之后的结果value。判断value大于0，直接返回0；如果value小于或等于0，说明加1之前的值小于0，可能存在等待的线程，然后调用函数_dispatch_semaphore_signal_slow，发送一个信号去唤起等待的线程。
long
_dispatch_semaphore_signal_slow(dispatch_semaphore_t dsema)
{
_dispatch_sema4_create(&dsema->dsema_sema, _DSEMA4_POLICY_FIFO);
_dispatch_sema4_signal(&dsema->dsema_sema, 1);
return 1;
}
_dispatch_semaphore_dispose源码解读
_dispatch_semaphore_dispose实际上就是信号量销毁时调用的方法：
void
_dispatch_semaphore_dispose(dispatch_object_t dou,
DISPATCH_UNUSED bool *allow_free)
{
dispatch_semaphore_t dsema = dou._dsema;
if (dsema->dsema_value < dsema->dsema_orig) {
DISPATCH_CLIENT_CRASH(dsema->dsema_orig - dsema->dsema_value,
"Semaphore object deallocated while in use");
}
_dispatch_sema4_dispose(&dsema->dsema_sema, _DSEMA4_POLICY_FIFO);
}
前面我们提到，在创建信号量时有两个属性dsema_value和dsema_orig接收value。其实dsema_orig是用来保留初始值，dsema_value在信号量使用过程中不断变化。等到dispose时，会判断dsema_value和dsema_orig是否相等，如果dsema_value小于初始值dsema_orig，那么系统就会认为信号量还在使用中，此时销毁就会发生crash。所以这是为什么信号量的dispatch_semaphore_signal和dispatch_semaphore_wait要成对使用的原因。
