简介

先来看看这几个主要函数:

/* 
功能：创建信号量
参数：value：信号量的初值，如果小于0则会返回NULL
返回值：信号量或空（失败）
*/
dispatch_semaphore_t dispatch_semaphore_create(long value);

/*
功能：阻塞当前线程等待降低信号量；
当信号量>0时，继续往下执行并让信号量减1
当信号量=0时，那么会等待信号量为非零才会执行下一步
或是时间结束，执行下一步
参数：dsema：信号量 timeout：限定时间
返回值：信号量强度
*/
long dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout);


/* 
功能：执行结束，不需要占用资源，提高信号量+1
参数：dsema：信号量
返回值：信号量强度
*/
long dispatch_semaphore_signal(dispatch_semaphore_t dsema);

可以理解为马路上的车道，
当信号量为1的时候就是1个车道，
当信号量为2的时候就是2个车道允许两辆车同时通过(两个线程同时执行)

信号量为1的时候可以控制线程执行顺序

某种意义上和 NSOperationQueue比较相似
信号量就是maxConcurrentOperationCount

示例1: 信号量1时，控制线程执行顺序

    //value 有几个车道
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
    dispatch_queue_t quene = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    //任务1
    dispatch_async(quene, ^{
//        NSLog(@"车1 发动");
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"车1 开始通过");
        sleep(2);
        NSLog(@"车1 已通过");
        dispatch_semaphore_signal(semaphore);
    });
    //任务2
    dispatch_async(quene, ^{
//        NSLog(@"车2 发动");
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"车2 开始通过");
        sleep(3);
        NSLog(@"车2 已通过");
        dispatch_semaphore_signal(semaphore);
    });
    //任务3
    dispatch_async(quene, ^{
//        NSLog(@"车3 发动");
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"车3 开始通过");
        sleep(1);
        NSLog(@"车3 已通过");
        dispatch_semaphore_signal(semaphore);
    });

输出结果

2018-01-03 12:01:17.239713+0800 GCD_Demo[1068:198835] 车1 开始通过
2018-01-03 12:01:19.242800+0800 GCD_Demo[1068:198835] 车1 已通过
2018-01-03 12:01:19.243025+0800 GCD_Demo[1068:199498] 车2 开始通过
2018-01-03 12:01:22.248172+0800 GCD_Demo[1068:199498] 车2 已通过
2018-01-03 12:01:22.248436+0800 GCD_Demo[1068:199521] 车3 开始通过
2018-01-03 12:01:23.253654+0800 GCD_Demo[1068:199521] 车3 已通过

这个案例中有个问题
这个案例的前提条件是dispatch_semaphore_wait能按照顺序执行，但是三个任务都处于不同的线程，不能完全保证按照顺序执行；
当然在正常情况下是没问题的，但是如果在dispatch_semaphore_wait之前加入NSLog(NSLog不仅仅只是打印信息,还记录到log中应该属于耗时操作)
在案例中就是 NSLog(@"车1 发动"); 注释的相关代码，输出结果很不稳定

2018-01-03 13:39:07.971221+0800 GCD_Demo[1280:300474] 车1 发动
2018-01-03 13:39:07.971221+0800 GCD_Demo[1280:301289] 车2 发动
2018-01-03 13:39:07.971241+0800 GCD_Demo[1280:301301] 车3 发动
2018-01-03 13:39:07.971365+0800 GCD_Demo[1280:301289] 车2 开始通过
2018-01-03 13:39:10.973622+0800 GCD_Demo[1280:301289] 车2 已通过
2018-01-03 13:39:10.973885+0800 GCD_Demo[1280:300474] 车1 开始通过
2018-01-03 13:39:12.979111+0800 GCD_Demo[1280:300474] 车1 已通过
2018-01-03 13:39:12.979332+0800 GCD_Demo[1280:301301] 车3 开始通过
2018-01-03 13:39:13.980507+0800 GCD_Demo[1280:301301] 车3 已通过

使用注意点

使用过程中避免在dispatch_semaphore_wait之前加入代码

示例2: 信号量为2的时候,资源池的运用

//value 有几个车道
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(2);
    dispatch_queue_t quene = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    //任务1
    dispatch_async(quene, ^{
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"车1 开始通过");
        sleep(2);
        NSLog(@"车1 已通过");
        dispatch_semaphore_signal(semaphore);
    });
    //任务2
    dispatch_async(quene, ^{
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"车2 开始通过");
        sleep(4);
        NSLog(@"车2 已通过");
        dispatch_semaphore_signal(semaphore);
    });
    //任务3
    dispatch_async(quene, ^{
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"车3 开始通过");
        sleep(1);
        NSLog(@"车3 已通过");
        dispatch_semaphore_signal(semaphore);
    });

输出结果

2018-01-03 13:56:23.688576+0800 GCD_Demo[1363:365452] 车1 开始通过
2018-01-03 13:56:23.688576+0800 GCD_Demo[1363:365436] 车2 开始通过
2018-01-03 13:56:25.691141+0800 GCD_Demo[1363:365452] 车1 已通过
2018-01-03 13:56:25.691367+0800 GCD_Demo[1363:365435] 车3 开始通过
2018-01-03 13:56:26.696554+0800 GCD_Demo[1363:365435] 车3 已通过
2018-01-03 13:56:27.690969+0800 GCD_Demo[1363:365436] 车2 已通过

从输出结果中的时间中看出，同时使用了两个资源，总耗时4s与预期结果一直。

总结: dispatch_semaphore 适合做多线程的资源池相关的功能，不太不适合做多线程同步相关的功能