GCD-信号量（dispatch_semaphore_t）

作者: 153037c65b0c | 来源:发表于2020-02-29 16:54 被阅读0次

1.信号量的简介

GCD的信号量主要涉及的函数有以下三个

//创建一个dispatch_semaphore_t类型的信号量，value是信号量的初始值
dispatch_semaphore_create(long value);
//等待信号量
dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout);
//发送信号量
dispatch_semaphore_signal(dispatch_semaphore_t dsema);

dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout);
等待信号量。如果信号量值为0，那么该函数就会一直等待，也就是不返回（相当于阻塞当前线程），直到该函数等待的信号量的值大于等于1，该函数会对信号量的值进行减1操作，然后返回。
第二个参数传入的是dispatch_time_t，表示过了这个时间就不再等待
dispatch_semaphore_signal(dispatch_semaphore_t deem);
发送信号量。该函数会对信号量的值进行加1操作。

2.信号量的用法

1.创建信号量，创建时设置信号量的初始值
2.在任务开始前添加dispatch_semaphore_wait函数，使任务等待（阻塞）
3.在任务结束后调用dispatch_semaphore_signal函数，释放一个信号量
信号量的dispatch_semaphore_wait和dispatch_semaphore_signal通常是成对出现的。
在当前任务执行之前，dispatch_semaphore_wait函数会判断当前的信号量是否大于等于1，若大于等于1，则会执行任务，并且把信号量减1，当任务完成后调用dispatch_semaphore_signal函数，信号量加1，否则会阻塞当前任务，当dispatch_semaphore_signal函数被调用时，信号量会加1，此时被阻塞的任务会继续进行。

3.使用信号量控制并发队列异步执行时的线程数量

以下列子中使用的都是并发队列，串行队列没有控制线程数量的意义，串行队列只会开辟一个子线程。

3.1异步执行并发队列控制子线程数最多为两个

dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(2);
    for (int i = 0; i < 5; i++) {
        dispatch_async(queue, ^{
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
            sleep(1);
            NSLog(@"任务%d 结束执行 当前线程：%@", i , [NSThread currentThread]);
            dispatch_semaphore_signal(semaphore);
        });
    }
    NSLog(@"主线程代码");

运行结果：

2020-02-29 11:16:21.441042+0800 Test[27081:1957822] 主线程代码
2020-02-29 11:16:22.446368+0800 Test[27081:1957912] 任务1 结束执行 当前线程：<NSThread: 0x600003ce8700>{number = 3, name = (null)}
2020-02-29 11:16:22.446400+0800 Test[27081:1957911] 任务0 结束执行 当前线程：<NSThread: 0x600003ce8380>{number = 4, name = (null)}
2020-02-29 11:16:23.448882+0800 Test[27081:1957904] 任务2 结束执行 当前线程：<NSThread: 0x600003cee5c0>{number = 5, name = (null)}
2020-02-29 11:16:23.448926+0800 Test[27081:1957924] 任务4 结束执行 当前线程：<NSThread: 0x600003ce8a80>{number = 6, name = (null)}
2020-02-29 11:16:24.449496+0800 Test[27081:1957910] 任务3 结束执行 当前线程：<NSThread: 0x600003ce9800>{number = 7, name = (null)}

在上述代码中，首先创建一个初始值为2的信号量，当子线程中的任务开始运行时调用dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);，判断信号量是否大于等于1，若大于等于1则继续执行，否则阻塞当前子线程。若执行了任务则信号量减1，执行完释放信号量。
因为dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);是在子线程中调用的，所以主线程之后的任务仍然可以并发执行。并且异步开启的五个任务不是按顺序执行的。
所以就达到了控制子线程数最多为两个的效果

把信号量的初始值设置为1，就可以达到一次只执行一个任务的效果，和串行队列的区别是任务可以在不同的子线程执行。可以充分发挥多线程的优势。（可以把上面例子中创建信号量时的值从2改为1，可以发现会隔一秒执行一个任务，在不同线程执行，执行先后顺序也不固定）

3.2把dispatch_semaphore_wait写到子线程之外

如果把dispatch_semaphore_wait写到子线程之外，此时会阻塞主线程，相当于信号量控制的是最多可以往队列添加任务的数量，此时如果信号量为1，任务会一个一个按顺序在多个线程执行，最后一个等待函数通过之后再执行主线程的代码，因为dispatch_semaphore_wait阻塞的是主线程

    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
    for (int i = 0; i < 5; i++) {
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        dispatch_async(queue, ^{
            sleep(1);
            NSLog(@"任务%d 结束执行 当前线程：%@", i , [NSThread currentThread]);
            dispatch_semaphore_signal(semaphore);
        });
    }
    NSLog(@"主线程代码");

运行结果：

2020-02-29 15:50:47.321348+0800 Test[29239:2124482] 任务0 结束执行 当前线程：<NSThread: 0x60000365d400>{number = 3, name = (null)}
2020-02-29 15:50:48.325445+0800 Test[29239:2124482] 任务1 结束执行 当前线程：<NSThread: 0x60000365d400>{number = 3, name = (null)}
2020-02-29 15:50:49.328935+0800 Test[29239:2124482] 任务2 结束执行 当前线程：<NSThread: 0x60000365d400>{number = 3, name = (null)}
2020-02-29 15:50:50.333874+0800 Test[29239:2124482] 任务3 结束执行 当前线程：<NSThread: 0x60000365d400>{number = 3, name = (null)}
2020-02-29 15:50:50.334178+0800 Test[29239:2124228] 主线程代码
2020-02-29 15:50:51.338454+0800 Test[29239:2124482] 任务4 结束执行 当前线程：<NSThread: 0x60000365d400>{number = 3, name = (null)}

由运行结果可以知道：
主线程等任务3结束之后马上就执行了，因为此时最后一个等待函数已经释放。
任务是按顺序一个一个执行的，因为在把任务添加到队列之前已经阻塞，所以不会并发。

由于添加的任务太少，sleep函数传入的时间太长，所以当前显示的是都在同一个子线程执行的，把sleep函数沉睡的时间改为0.001，子线程添加100个任务，此时可以看到会在不同子线程执行任务，说明可以充分利用CPU的多线程优势

4.队列组和信号量的组合使用

GCD-队列组
假设有一个需求：要并发执行两个任务，并且在每个任务中请求一次网络，等两次请求都完成后再去执行队列组监听回调中的任务。

4.1如果不使用信号量，只用队列组，达不到效果的用法

    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue= dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_async(group, queue, ^{
        NSLog(@"开始任务1");
        sleep(1);
        dispatch_async(queue, ^{
            NSLog(@"任务1中的网络请求开始");
            sleep(2);
            NSLog(@"任务1中的网络请求结束");
        });
        NSLog(@"结束任务1");
    });
    dispatch_group_async(group, queue, ^{
        NSLog(@"开始任务2");
        sleep(1);
        dispatch_async(queue, ^{
            NSLog(@"任务2中的网络请求开始");
            sleep(2);
            NSLog(@"任务2中的网络请求结束");
        });
        NSLog(@"结束任务2");
    });
    dispatch_group_notify(group, queue, ^{
        NSLog(@"回调中的任务，需要最后执行");
    });

运行结果：

2020-02-29 16:17:11.362046+0800 Test[29549:2162983] 开始任务2
2020-02-29 16:17:11.362046+0800 Test[29549:2162991] 开始任务1
2020-02-29 16:17:12.366653+0800 Test[29549:2162983] 结束任务2
2020-02-29 16:17:12.366694+0800 Test[29549:2162992] 任务2中的网络请求开始
2020-02-29 16:17:12.366634+0800 Test[29549:2162991] 结束任务1
2020-02-29 16:17:12.366737+0800 Test[29549:2162993] 任务1中的网络请求开始
2020-02-29 16:17:12.366936+0800 Test[29549:2162983] 回调中的任务，需要最后执行
2020-02-29 16:17:14.368896+0800 Test[29549:2162992] 任务2中的网络请求结束
2020-02-29 16:17:14.368895+0800 Test[29549:2162993] 任务1中的网络请求结束

可以发现如果只用了队列组的方式，回调中的任务会在网络请求结束前就调用，因为网络请求用的也是异步的，所以不会阻塞线程，队列组监听的任务1，2会在网络请求返回前就已经结束。

4.2只用队列组，完成需求的方法

    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue= dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_async(group, queue, ^{
        NSLog(@"开始任务1");
        sleep(1);
        dispatch_group_async(group, queue, ^{
            NSLog(@"任务1中的网络请求开始");
            sleep(2);
            NSLog(@"任务1中的网络请求结束");
        });
        NSLog(@"结束任务1");
    });
    dispatch_group_async(group, queue, ^{
        NSLog(@"开始任务2");
        sleep(1);
        dispatch_group_async(group, queue, ^{
            NSLog(@"任务2中的网络请求开始");
            sleep(2);
            NSLog(@"任务2中的网络请求结束");
        });
        NSLog(@"结束任务2");
    });
    dispatch_group_notify(group, queue, ^{
        NSLog(@"回调中的任务，需要最后执行");
    });

执行结果：

2020-02-29 16:20:42.986496+0800 Test[29599:2168460] 开始任务2
2020-02-29 16:20:42.986496+0800 Test[29599:2168459] 开始任务1
2020-02-29 16:20:43.986974+0800 Test[29599:2168459] 结束任务1
2020-02-29 16:20:43.986987+0800 Test[29599:2168460] 结束任务2
2020-02-29 16:20:43.987026+0800 Test[29599:2168465] 任务2中的网络请求开始
2020-02-29 16:20:43.987046+0800 Test[29599:2168453] 任务1中的网络请求开始
2020-02-29 16:20:45.988794+0800 Test[29599:2168453] 任务1中的网络请求结束
2020-02-29 16:20:45.988794+0800 Test[29599:2168465] 任务2中的网络请求结束
2020-02-29 16:20:45.989003+0800 Test[29599:2168453] 回调中的任务，需要最后执行

这种写法相当于在任务1和2的代码最后，把他们各自的网络请求任务又加入了队列组，因为此时队列组中的任务还没完成，所以不会进回调，队列组中又被新加任务，所以需要等任务组中的任务都完成，才会执行回调。

4.3用队列组的dispatch_group_enter和dispatch_group_leave

dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue= dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        NSLog(@"开始任务1");
        sleep(1);
        dispatch_async(queue, ^{
            NSLog(@"任务1中的网络请求开始");
            sleep(2);
            NSLog(@"任务1中的网络请求结束");
            dispatch_group_leave(group);
            });
        NSLog(@"结束任务1");
    });
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        NSLog(@"开始任务2");
        sleep(1);
        dispatch_async(queue, ^{
            NSLog(@"任务2中的网络请求开始");
            sleep(2);
            NSLog(@"任务2中的网络请求结束");
            dispatch_group_leave(group);
        });
        NSLog(@"结束任务2");
    });
    dispatch_group_notify(group, queue, ^{
        NSLog(@"回调中的任务，需要最后执行");
    });

执行结果：

2020-02-29 16:28:28.805932+0800 Test[29727:2180149] 开始任务1
2020-02-29 16:28:28.805932+0800 Test[29727:2180146] 开始任务2
2020-02-29 16:28:29.808428+0800 Test[29727:2180146] 结束任务2
2020-02-29 16:28:29.808428+0800 Test[29727:2180149] 结束任务1
2020-02-29 16:28:29.808512+0800 Test[29727:2180155] 任务1中的网络请求开始
2020-02-29 16:28:29.808556+0800 Test[29727:2180150] 任务2中的网络请求开始
2020-02-29 16:28:31.813638+0800 Test[29727:2180155] 任务1中的网络请求结束
2020-02-29 16:28:31.813638+0800 Test[29727:2180150] 任务2中的网络请求结束
2020-02-29 16:28:31.814062+0800 Test[29727:2180155] 回调中的任务，需要最后执行

dispatch_group_enter表示进入了这个队列组，dispatch_group_leave表示离开这个队列组，dispatch_group_leave在任务1，2的网络请求结束之后再调用，所以被回调时已经结束了所有任务

4.4队列组和信号量组合使用

    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue= dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_async(group, queue, ^{
        NSLog(@"开始任务1");
        sleep(1);
        dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
        dispatch_async(queue, ^{
            NSLog(@"任务1中的网络请求开始");
            sleep(2);
            NSLog(@"任务1中的网络请求结束");
            dispatch_semaphore_signal(semaphore);
        });
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"结束任务1");
    });
    dispatch_group_async(group, queue, ^{
        NSLog(@"开始任务2");
        sleep(1);
        dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
        dispatch_async(queue, ^{
            NSLog(@"任务2中的网络请求开始");
            sleep(2);
            NSLog(@"任务2中的网络请求结束");
            dispatch_semaphore_signal(semaphore);
        });
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"结束任务2");
    });
    dispatch_group_notify(group, queue, ^{
        NSLog(@"回调中的任务，需要最后执行");
    });

执行结果：

2020-02-29 16:34:46.148453+0800 Test[29835:2191521] 开始任务1
2020-02-29 16:34:46.148486+0800 Test[29835:2191528] 开始任务2
2020-02-29 16:34:47.151338+0800 Test[29835:2191527] 任务2中的网络请求开始
2020-02-29 16:34:47.151341+0800 Test[29835:2191529] 任务1中的网络请求开始
2020-02-29 16:34:49.152982+0800 Test[29835:2191527] 任务2中的网络请求结束
2020-02-29 16:34:49.152982+0800 Test[29835:2191529] 任务1中的网络请求结束
2020-02-29 16:34:49.153431+0800 Test[29835:2191521] 结束任务1
2020-02-29 16:34:49.153438+0800 Test[29835:2191528] 结束任务2
2020-02-29 16:34:49.153697+0800 Test[29835:2191528] 回调中的任务，需要最后执行

代码解析：
1.在任务1、2的网络请求任务开始前新建一个初始值为0的信号量（dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);）
2.因为网络请求任务是异步执行的，所以任务1、2不会管网络请求是否完成，直接执行网络请求代码块之后的代码，此时阻塞任务1、2所在的线程（dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);）
3.在网络请求完成之后释放信号量（dispatch_semaphore_signal(semaphore);），此时信号量从0变成1，任务1、2可以继续往下执行（），任务1、2执行完成之后dispatch_group_notify收到回调，执行里面的代码。

参考：
GCD信号量-dispatch_semaphore_t

GCD-信号量（dispatch_semaphore_t）

1.信号量的简介

2.信号量的用法

3.使用信号量控制并发队列异步执行时的线程数量

3.1异步执行并发队列控制子线程数最多为两个

3.2把dispatch_semaphore_wait写到子线程之外

4.队列组和信号量的组合使用

4.1如果不使用信号量，只用队列组，达不到效果的用法

4.2只用队列组，完成需求的方法

4.3用队列组的dispatch_group_enter和dispatch_group_leave

4.4队列组和信号量组合使用

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读