iOS --- GCD 信号量控制并发 （dispatch_semaphore）

转自:http://blog.csdn.net/fhbystudy/article/details/25918451

当我们在处理一系列线程的时候，当数量达到一定量，在以前我们可能会选择使用NSOperationQueue来处理并发控制，但如何在GCD中快速的控制并发呢？答案就是dispatch_semaphore，对经常做unix开发的人来讲，我所介绍的内容可能就显得非常入门级了，信号量在他们的多线程开发中再平常不过了。
　　信号量是一个整形值并且具有一个初始计数值，并且支持两个操作：信号通知和等待。当一个信号量被信号通知，其计数会被增加。当一个线程在一个信号量上等待时，线程会被阻塞（如果有必要的话），直至计数器大于零，然后线程会减少这个计数。
　　在GCD中有三个函数是semaphore的操作，分别是：
　　dispatch_semaphore_create　　　创建一个semaphore
　　dispatch_semaphore_signal　　　发送一个信号
　　dispatch_semaphore_wait　　　　等待信号
　　简单的介绍一下这三个函数，第一个函数有一个整形的参数，我们可以理解为信号的总量，dispatch_semaphore_signal是发送一个信号，自然会让信号总量加1，dispatch_semaphore_wait等待信号，当信号总量少于0的时候就会一直等待，否则就可以正常的执行，并让信号总量-1，根据这样的原理，我们便可以快速的创建一个并发控制来同步任务和有限资源访问控制。

[cpp] view plaincopy

1. dispatch_group_t group = dispatch_group_create();   
2.     dispatch_semaphore_t semaphore = dispatch_semaphore_create(10);   
3.     dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);   
4.     for (int i = 0; i < 100; i++)   
5.     {   
6.         dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);   
7.         dispatch_group_async(group, queue, ^{   
8.             NSLog(@"%i",i);   
9.             sleep(2);   
10.             dispatch_semaphore_signal(semaphore);   
11.         });   
12.     }   
13.     dispatch_group_wait(group, DISPATCH_TIME_FOREVER);   
14.     dispatch_release(group);   
15.     dispatch_release(semaphore);   

　　简单的介绍一下这一段代码，创建了一个初使值为10的semaphore，每一次for循环都会创建一个新的线程，线程结束的时候会发送一个信号，线程创建之前会信号等待，所以当同时创建了10个线程之后，for循环就会阻塞，等待有线程结束之后会增加一个信号才继续执行，如此就形成了对并发的控制，如上就是一个并发数为10的一个线程队列。

简单示例

 

[cpp] view plaincopy

1. __block BOOL isok = NO;  
2.       
3.     dispatch_semaphore_t sema = dispatch_semaphore_create(0);  
4.     Engine *engine = [[Engine alloc] init];  
5.     [engine queryCompletion:^(BOOL isOpen) {  
6.         isok = isOpen;  
7.         dispatch_semaphore_signal(sema);  
8.     } onError:^(int errorCode, NSString *errorMessage) {  
9.         isok = NO;  
10.         dispatch_semaphore_signal(sema);  
11.     }];  
12.       
13.     dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);  
14.     dispatch_release(sema);

相关内容二:

转载请注明出处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, 1*1000*1000*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）就只能等待。有可能同时有几辆车等待一个停车位。有些车主

　　没有耐心，给自己设定了一段等待时间，这段时间内等不到停车位就走了，如果等到了就开进去停车。而有些车主就像把车停在这，

　　所以就一直等下去。

 

（7）代码举简单示例如下：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

　  dispatch_semaphore_t signal;

    signal = dispatch_semaphore_create(1);

    __block long x = 0;

    NSLog(@"0_x:%ld",x);

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        sleep(1);

        NSLog(@"waiting");

        x = dispatch_semaphore_signal(signal);

        NSLog(@"1_x:%ld",x);

 

        sleep(2);

        NSLog(@"waking");

        x = dispatch_semaphore_signal(signal);

        NSLog(@"2_x:%ld",x);

    });

//    dispatch_time_t duration = dispatch_time(DISPATCH_TIME_NOW, 1*1000*1000*1000); //超时1秒

//    dispatch_semaphore_wait(signal, duration);

 

    x = dispatch_semaphore_wait(signal, DISPATCH_TIME_FOREVER);

    NSLog(@"3_x:%ld",x);

 

    x = dispatch_semaphore_wait(signal, DISPATCH_TIME_FOREVER);

    NSLog(@"wait 2");

    NSLog(@"4_x:%ld",x);

 

    x = dispatch_semaphore_wait(signal, DISPATCH_TIME_FOREVER);

    NSLog(@"wait 3");

    NSLog(@"5_x:%ld",x);

 

 

最终打印的结果为：

1

2

3

4

5

6

7

8

9

10

2014-08-11 22:51:54.734 LHTest[15700:70b] 0_x:0

2014-08-11 22:51:54.737 LHTest[15700:70b] 3_x:0

2014-08-11 22:51:55.738 LHTest[15700:f03] waiting

2014-08-11 22:51:55.739 LHTest[15700:70b] wait 2

2014-08-11 22:51:55.739 LHTest[15700:f03] 1_x:1

2014-08-11 22:51:55.739 LHTest[15700:70b] 4_x:0

2014-08-11 22:51:57.741 LHTest[15700:f03] waking

2014-08-11 22:51:57.742 LHTest[15700:f03] 2_x:1

2014-08-11 22:51:57.742 LHTest[15700:70b] wait 3

2014-08-11 22:51:57.742 LHTest[15700:70b] 5_x:0




相关内容三:

转自:http://www.cnblogs.com/yajunLi/p/6274282.html

理解这个概念之前，先抛出一个问题

问题描述：

假设现在系统有两个空闲资源可以被利用，但同一时间却有三个线程要进行访问，这种情况下，该如何处理呢？

 

没错，这里，我们就可以方便的利用信号量来解决这个问题。

 

1、信号量：就是一种可用来控制访问资源的数量的标识，设定了一个信号量，在线程访问之前，加上信号量的处理，则可告知系统按照我们指定的信号量数量来执行多个线程。

其实，这有点类似锁机制了，只不过信号量都是系统帮助我们处理了，我们只需要在执行线程之前，设定一个信号量值，并且在使用时，加上信号量处理方法就行了。

 

2、信号量主要有3个函数，分别是：

1

2

3

4

5

6

7

8

//创建信号量，参数：信号量的初值，如果小于0则会返回NULL

dispatch_semaphore_create（信号量值）

 

//等待降低信号量

dispatch_semaphore_wait（信号量，等待时间）

 

//提高信号量

dispatch_semaphore_signal(信号量)

　　

注意，正常的使用顺序是先降低然后再提高，这两个函数通常成对使用。　（具体可参考下面的代码示例）　

 

3、那么就开头提的问题，我们用代码来解决

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

-(void)dispatchSignal{

    //crate的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(@"run task 1");

        sleep(1);

        NSLog(@"complete task 1");

        dispatch_semaphore_signal(semaphore);       

    });<br>

    //任务2

    dispatch_async(quene, ^{

        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

        NSLog(@"run task 2");

        sleep(1);

        NSLog(@"complete task 2");

        dispatch_semaphore_signal(semaphore);       

    });<br>

    //任务3

    dispatch_async(quene, ^{

        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

        NSLog(@"run task 3");

        sleep(1);

        NSLog(@"complete task 3");

        dispatch_semaphore_signal(semaphore);       

    });   

}

执行结果：

　　

总结：由于设定的信号值为2，先执行两个线程，等执行完一个，才会继续执行下一个，保证同一时间执行的线程数不超过2。

 

这里我们扩展一下，假设我们设定信号值=1

1

dispatch_semaphore_create(1)<br><br>

那么结果就是：

 

如果设定信号值=3

1

dispatch_semaphore_create(3)<br><br>

那么结果就是： 

其实设定为3，就是不限制线程执行了，因为一共才只有3个线程。