队列组

队列组的简单使用 -- 监听任务的完成

1、所有的任务会并发的执行(不按序)

2、所有的异步函数, 都是添加到队列中, 然后再纳入到队列组的监听范围

3、使用dispatch_group_notify(队列组, 队列)函数, 来监听在这个函数上面的任务执行是否完成, 当任务完成, 就会调用这个方法

// 1. 创建队列组
dispatch_group_t group = dispatch_group_create(); 
// 2. 创建并发队列 
dispatch_queue_t queue = dispatch_queue_create("123", DISPATCH_QUEUE_CONCURRENT); 
// 3. 使用函数添加任务 
dispatch_group_async(group, queue, ^{ 
    NSLog(@"1---%@", [NSThread currentThread]);
 }); 
dispatch_group_async(group, queue, ^{
     NSLog(@"2---%@", [NSThread currentThread]); 
});
 dispatch_group_async(group, queue, ^{ 
    NSLog(@"3---%@", [NSThread currentThread]); 
}); 
dispatch_group_async(group, queue, ^{ 
    NSLog(@"4---%@", [NSThread currentThread]); 
}); 
// 4. 让队列组监听任务的完成 
dispatch_group_notify(group, queue, ^{ 
    NSLog(@"执行完毕"); 
});

信号量

问题描述：

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

或者

我们要下载很多图片，并发异步进行，每个下载都会开辟一个新线程，可是我们又担心太多线程cpu肯定吃不消，那么我们这里也可以用信号量控制一下最大开辟线程数。

定义：

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

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

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

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

//等待降低信号量
dispatch_semaphore_wait（信号量，等待时间）

//提高信号量
dispatch_semaphore_signal(信号量)

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

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

-(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);        

    });

    //任务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);        

    });

    //任务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);        

    });    

}

执行结果：

image.png

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

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

dispatch_semaphore_create(1)

那么结果就是：

image.png

如果设定信号值=3

dispatch_semaphore_create(3)

那么结果就是：

image.png

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

栅栏函数

当我们的任务有依赖关系的时候，比如任务1和2执行完毕后才能执行任务3和4，这时候我们可以用到这个函数——栅栏函数。其中 queue 是队列，block 是任务。

提交一个栅栏函数在同步执行中,它会等待栅栏函数执行完再去执行下一行代码（注意是下一行代码），同步栅栏函数是在当前线程中执行的

dispatch_barrier_sync(dispatch_queue_t queue, dispatch_block_t blcok);

提交一个栅栏函数在异步执行中,它会立马返回开始执行下一行代码（不用等待任务执行完毕）

dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t blcok);

共同点

都会等待在它前面插入队列的任务（1、2、3）先执行完 2、都会等待他们自己的任务（barrier）执行完再执行后面的任务（4、5、6）（注意这里说的是任务不是下一行代码）

不同点

dispatch_barrier_sync需要等待自己的任务（barrier）结束之后，才会继续添加并执行写在barrier后面的任务（4、5、6），然后执行后面的任务 2、dispatch_barrier_async将自己的任务（barrier）插入到queue之后，不会等待自己的任务结束，它会继续把后面的任务（4、5、6）插入到queue，然后执行任务。

// 并发队列 栅栏函数 
- (void)concurrentQueueAsyncAndSync2BarrierTest {
    dispatch_queue_t queue = dispatch_queue_create("com.barrier", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(queue, ^{
        NSLog(@"任务0 start");
        sleep(1);
        NSLog(@"任务0 end");
    });
    
    dispatch_async(queue, ^{
        NSLog(@"任务1 start");
        sleep(1);
        NSLog(@"任务1 end");
    });
    
    NSLog(@"同步栅栏 start 😄");
    dispatch_barrier_sync(queue, ^{
        NSLog(@"同步栅栏 任务 start");
        sleep(1);
        NSLog(@"同步栅栏 任务 end");
    });
    NSLog(@"同步栅栏 end 😄");
    
    dispatch_async(queue, ^{
        NSLog(@"任务2 start");
        sleep(1);
        NSLog(@"任务2 end");
    });
    
    NSLog(@"异步栅栏 start 😄");
    dispatch_barrier_async(queue, ^{
        NSLog(@"异步栅栏栅栏 任务 start");
        sleep(1);
        NSLog(@"异步栅栏栅栏 任务 end");
    });
    NSLog(@"异步栅栏栅栏 end 😄");
    
    dispatch_async(queue, ^{
        NSLog(@"任务3 start");
        sleep(1);
        NSLog(@"任务3 end");
    });
    
    dispatch_async(queue, ^{
        NSLog(@"任务4 start");
        sleep(1);
        NSLog(@"任务4 end");
    });
}

打印结果如下：

2019-03-17 16:17:50.447824+0800 网络请求Demo[3358:203368] 同步栅栏 start 😄
2019-03-17 16:17:50.447838+0800 网络请求Demo[3358:203589] 任务0 start
2019-03-17 16:17:50.447871+0800 网络请求Demo[3358:203806] 任务1 start
2019-03-17 16:17:51.451935+0800 网络请求Demo[3358:203806] 任务1 end
2019-03-17 16:17:51.451935+0800 网络请求Demo[3358:203589] 任务0 end
2019-03-17 16:17:51.452211+0800 网络请求Demo[3358:203368] 同步栅栏 任务 start
2019-03-17 16:17:52.452917+0800 网络请求Demo[3358:203368] 同步栅栏 任务 end
2019-03-17 16:17:52.453108+0800 网络请求Demo[3358:203368] 同步栅栏 end 😄
2019-03-17 16:17:52.453240+0800 网络请求Demo[3358:203368] 异步栅栏 start 😄
2019-03-17 16:17:52.453280+0800 网络请求Demo[3358:203809] 任务2 start
2019-03-17 16:17:52.453368+0800 网络请求Demo[3358:203368] 异步栅栏栅栏 end 😄
2019-03-17 16:17:53.067835+0800 网络请求Demo[3358:203368] GCDBarrierController
2019-03-17 16:17:53.458678+0800 网络请求Demo[3358:203809] 任务2 end
2019-03-17 16:17:53.458902+0800 网络请求Demo[3358:203809] 异步栅栏栅栏 任务 start
2019-03-17 16:17:54.462291+0800 网络请求Demo[3358:203809] 异步栅栏栅栏 任务 end
2019-03-17 16:17:54.462529+0800 网络请求Demo[3358:203809] 任务3 start
2019-03-17 16:17:54.462534+0800 网络请求Demo[3358:203806] 任务4 start
2019-03-17 16:17:55.465377+0800 网络请求Demo[3358:203806] 任务4 end
2019-03-17 16:17:55.465391+0800 网络请求Demo[3358:203809] 任务3 end

情景分析：

同步栅栏添加进入队列的时候，当前线程会被锁死，直到同步栅栏之前的任务和同步栅栏任务本身执行完毕时，当前线程才会打开然后继续执行下一句代码。

注意：

在使用栅栏函数时.使用自定义队列才有意义,如果用的是串行队列或者系统提供的全局并发队列,这个栅栏函数的作用等同于一个同步函数的作用