信号量-->semaphore

转载请注明出处http://www.cnblogs.com/snailHL/p/3906112.html

dispatch_semaphore是GCD用来同步的一种方式，与他相关的共有三个函数，分别是
dispatch_semaphore_create，dispatch_semaphore_signal，dispatch_semaphore_wait。
下面我们逐一介绍三个函数：
（1）dispatch_semaphore_create的声明为：
　　dispatch_semaphore_t dispatch_semaphore_create(long value);
　　传入的参数为long，输出一个dispatch_semaphore_t类型且值为value的信号量。
　　值得注意的是，这里的传入的参数value必须大于或等于0，否则dispatch_semaphore_create会返回NULL。
　　（关于信号量，我就不在这里累述了，网上很多介绍这个的。我们这里主要讲一下dispatch_semaphore这三个函数的用法）。

（2）dispatch_semaphore_signal的声明为：
　　long dispatch_semaphore_signal(dispatch_semaphore_t dsema)
　　这个函数会使传入的信号量dsema的值加1；（至于返回值，待会儿再讲）

(3) dispatch_semaphore_wait的声明为：
　　long dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout)；
　　这个函数会使传入的信号量dsema的值减1；
　　这个函数的作用是这样的，如果dsema信号量的值大于0，该函数所处线程就继续执行下面的语句，并且将信号量的值减1；
　　如果desema的值为0，那么这个函数就阻塞当前线程等待timeout（注意timeout的类型为dispatch_time_t，
　　不能直接传入整形或float型数），如果等待的期间desema的值被dispatch_semaphore_signal函数加1了，
　　且该函数（即dispatch_semaphore_wait）所处线程获得了信号量，那么就继续向下执行并将信号量减1。
　　如果等待期间没有获取到信号量或者信号量的值一直为0，那么等到timeout时，其所处线程自动执行其后语句。
　　
（4）dispatch_semaphore_signal的返回值为long类型，当返回值为0时表示当前并没有线程等待其处理的信号量，其处理
　　的信号量的值加1即可。当返回值不为0时，表示其当前有（一个或多个）线程等待其处理的信号量，并且该函数唤醒了一
　　个等待的线程（当线程有优先级时，唤醒优先级最高的线程；否则随机唤醒）。
　　dispatch_semaphore_wait的返回值也为long型。当其返回0时表示在timeout之前，该函数所处的线程被成功唤醒。
　　当其返回不为0时，表示timeout发生。

（5）在设置timeout时，比较有用的两个宏：DISPATCH_TIME_NOW 和 DISPATCH_TIME_FOREVER。
　　DISPATCH_TIME_NOW　　表示当前；
　　DISPATCH_TIME_FOREVER　　表示遥远的未来；
　　一般可以直接设置timeout为这两个宏其中的一个，或者自己创建一个dispatch_time_t类型的变量。
　　创建dispatch_time_t类型的变量有两种方法，dispatch_time和dispatch_walltime。
　　利用创建dispatch_time创建dispatch_time_t类型变量的时候一般也会用到这两个变量。
　　dispatch_time的声明如下：
　　dispatch_time_t dispatch_time(dispatch_time_t when, int64_t delta)；
　　其参数when需传入一个dispatch_time_t类型的变量，和一个delta值。表示when加delta时间就是timeout的时间。
　　例如：dispatch_time_t t = dispatch_time(DISPATCH_TIME_NOW, 110001000*1000);
　　　　　表示当前时间向后延时一秒为timeout的时间。

（6）关于信号量，一般可以用停车来比喻。
　　停车场剩余4个车位，那么即使同时来了四辆车也能停的下。如果此时来了五辆车，那么就有一辆需要等待。
　　信号量的值就相当于剩余车位的数目，dispatch_semaphore_wait函数就相当于来了一辆车，dispatch_semaphore_signal
　　就相当于走了一辆车。停车位的剩余数目在初始化的时候就已经指明了（dispatch_semaphore_create（long value）），
　　调用一次dispatch_semaphore_signal，剩余的车位就增加一个；调用一次dispatch_semaphore_wait剩余车位就减少一个；
　　当剩余车位为0时，再来车（即调用dispatch_semaphore_wait）就只能等待。有可能同时有几辆车等待一个停车位。有些车主
　　没有耐心，给自己设定了一段等待时间，这段时间内等不到停车位就走了，如果等到了就开进去停车。而有些车主就像把车停在这，
　　所以就一直等下去。

信号量就是控制能同时执行多少个任务，wait就是判断是否需要等待，如果这是信号量大于0，就执行它后面的代码，并且把信号量减一，任务执行完毕再执行signal，把信号量加一。每个任务都遵循这个规则，保证同时执行的任务数量不会大于信号量。

2019续：面试问到这个问题，答的一沓糊涂，机会也浪费了，再看看，敲一遍，加深了解。

//创建信号量，参数：信号量的初值，如果小于0则会返回NULL
dispatch_semaphore_create（信号量值）
//等待降低信号量
dispatch_semaphore_wait（信号量，等待时间）
//提高信号量
dispatch_semaphore_signal(信号量)
注意，正常的使用顺序是先降低然后再提高，这两个函数通常成对使用

用处一、控制线程并发

   dispatch_queue_t queue_A = dispatch_get_global_queue(0, 0);
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(3);
    for (int i = 0; i < 5; i++) {
        dispatch_async(queue_A, ^{
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
            NSLog(@"第%d个子线程--开始", i);
            int x = 0.5 + arc4random() % 3;//模拟耗时不同，更加真实些
            sleep(x);//生命减少1s
            NSLog(@"第%d个子线程--结束", i);
            dispatch_semaphore_signal(semaphore);
        });
    }

控制并发.png

创建了一个数量是3的信号量。
通过循环，创建5个子线程。子线程开始就执行wait，此时信号量是3，大于0，所以wait执行，信号量减1。由于是并发，没有先后顺序，5个子线程同时开始工作。率先执行wait方法的3个子线程执行完wait，等到第4个和第5个子线程的时候，此时信号量是0，wait不执行，剩下的2子线程被阻塞。
前面的子线程执行完，执行signal，对信号量+1，被阻塞的子线程监听到信号量不为0了，开始执行wait，并且对信号量减1。
这么下去，保证同时执行的子线程最大数量就是3，超出3，就被阻塞，只能等着其他线程结束，这样就实现了控制线程并发数量。

二、线程安全，加锁

根据上面可知，信号量可以控制线程并发数量，如果初始化信号量为1，此时就相当于只能执行一个线程，如果有多个线程去读写一个数据，这种情况下就可以把信号量初始化为1，保证了数据安全。
比如这么用：

   dispatch_queue_t queue_A = dispatch_get_global_queue(0, 0);
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
    for (int i = 0; i < 5; i++) {
        dispatch_async(queue_A, ^{
            int x = 0.5 + arc4random() % 3;
            sleep(x);//生命减少1s
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
            NSLog(@"第%d个子线程--开始", i);
            [self.dataArr addObject:@"暴力"];
            NSLog(@"第%d个子线程--结束", i);
            dispatch_semaphore_signal(semaphore);
        });
    }

这样当前线程执行的时候，其他线程被阻塞。保证了数据安全。

加锁.png

开始结束每次执行，只保证一个线程对数据读写。

三、实现串行

如果把信号量初始化0。在子线程中，如果先执行wait的话，就被阻塞了。不行。
但是如果把wait放在主线程，在子线程中signal提高信号量。这样就把主线程阻塞，实现子线程按顺序执行，相当于串行队列的功能。
虽然感觉没啥卵用，直接同步执行队列，或者使用串行队列都能实现。就是算一种实现同步的方法。
我试试。

    dispatch_queue_t queue_A = dispatch_get_global_queue(0, 0);
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    for (int i = 0; i < 5; i++) {
        dispatch_async(queue_A, ^{
            //子线程
            NSLog(@"第%d个子线程--开始", i);
            [self.dataArr addObject:@"暴力"];
            NSLog(@"第%d个子线程--结束", i);
            dispatch_semaphore_signal(semaphore);
        });
        //主线程
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    }

用同步执行dispatch_sync也能实现这种顺序执行。（感觉没卵用）

    dispatch_queue_t queue_A = dispatch_get_global_queue(0, 0);
    for (int i = 0; i < 5; i++) {
        dispatch_sync(queue_A, ^{
            //子线程
            NSLog(@"第%d个子线程--开始", i);
            int x = 0.5 + arc4random() % 3;
            sleep(x);//生命减少1s
            [self.dataArr addObject:@"暴力"];
            NSLog(@"第%d个子线程--结束", i);
        });
    }

用串行队列实现

dispatch_queue_t queue_B = dispatch_queue_create("串行队列", DISPATCH_QUEUE_SERIAL);

dispatch_sync和dispatch_async都行。
队列用串行，子线程执行方式async和sync都没有影响，都会按顺序执行。

串行、并行影响当前队列中任务的执行顺序，有序和无序。
同步、异步影响是否能开新线程de能力。
DISPATCH_QUEUE_SERIAL串行
DISPATCH_QUEUE_CONCURRENT并行

dispatch_sync同步
dispatch_async异步
四种组合方式。
使用同步，意味着不会开新线程，队列的串行或并行没有区别，都按顺序执行。都在主线程。
使用异步，意味着有开新线程的能力。队列用串行，只会开辟一个就够了。并行的话，会开辟多个子线程。
还有一个特殊的队列：主队列，dispatch_get_main_queue
如果对主队列使用同步，会造成死锁。为什么？为什么❓
如果对主队列使用异步，任务会回到主线程。因为主队列里的任务只能在主线程执行。