dispatch_group-从概念到基本的使用

关于dispatch_group就是把一组任务交到队列中，这些队列可以不相关，然后监听这组任务完成的事件

常见的几个方法：

• dispatch_group_create 创建一个调度任务组
• dispatch_group_async 把一个任务异步提交到任务组
• dispatch_group_enter/dispatch_group_leave 这种方式用在不使用dispatch_group_async来提交任务，且必须配合使用
• dispatch_group_notify 用来监听任务组事件的执行完毕
• dispatch_group_wait 设置等待时间，在等待时间结束后，如果还没有执行任务组，则返回。返回0表示执行成功，非0则执行失败

 -(void)methodOne{
    dispatch_group_t group = dispatch_group_create();
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        //请求1
        debugLog(@"Request1");
    });
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        //请求2
        debugLog(@"Request2");
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        //请求3
        debugLog(@"Request3");
    });
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        //刷新界面
        debugLog(@"任务完成，刷新界面");
    });
}

以上方法的问题，网络请求一般都是异步的，并不知道什么时候是否完成
如何解决?利用dispatch_group_enter()看下面的方法

-(void)methodTwo{
    dispatch_group_t group = dispatch_group_create();
    
    dispatch_group_enter(group);
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        //请求1
       [网络请求:
           成功：dispatch_group_leave(group);
           失败：dispatch_group_leave(group);
       }]
    });
    
    dispatch_group_enter(group);
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       //请求2
                [网络请求:{
                    成功：dispatch_group_leave(group);
                    失败：dispatch_group_leave(group);
                }]
        
    });
    
    dispatch_group_enter(group);
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       //请求3
                [网络请求:{
                    成功：dispatch_group_leave(group);
                    失败：dispatch_group_leave(group);
                }]
    });
    
    //一直等待完成
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        //界面刷新
        debugLog(@"任务完成，界面刷新");
    });
}

继续，如果想要控制访问资源怎么办？这里简单说说信号量的机制

信号量：就是一种可用来控制访问资源的数量标识符设定了一个信号量，在线程访问之前，加上信号量，则可告知系统按照我们指定的信号量数量来执行多个线程， 其实，这有点类似锁机制了，只不过信号量都是系统帮助我们处理了，只需要在执行线程之前，设定一个信号量值，并且在使用时，加上信号量处理方法就行

• 信号量主要有三个函数：分别是
• 创建信号量。参数：信号量的初始值 如果小于0则会返回NULL
• dispatch_semaphore_create(信号量值)
• 等待降低信号量
• dispatch_semaphore_wait(信号量，等待时间)
• 提高信号量
• dispatch_semaphore_signal(信号量)

-(void)disptchSinal{
    
    //create 的value表示 最多可访问z几个资源
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(2);
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    //任务1
    dispatch_async(queue, ^{
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        debugLog(@"run task 1");
        sleep(1);
        debugLog(@"complete task 1");
        dispatch_semaphore_signal(semaphore);
    });
    
    //任务2
    dispatch_async(queue, ^{
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        debugLog(@"run task2");
        sleep(1);
        debugLog(@"complete task 2");
        dispatch_semaphore_signal(semaphore);
    });
    
    //任务3
    dispatch_async(queue, ^{
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        debugLog(@"run task3");
        sleep(1);
        debugLog(@"complete task 3");
        dispatch_semaphore_signal(semaphore);
    });
    
    /*
     2019-03-08 15:57:14.172134+0800 demo[9895:195878] run task 1
     2019-03-08 15:57:14.172134+0800 demo[9895:195871] run task2
     2019-03-08 15:57:15.176204+0800 demo[9895:195878] complete task 1
     2019-03-08 15:57:15.176206+0800 demo[9895:195871] complete task 2
     2019-03-08 15:57:15.176485+0800 demo[9895:195877] run task3
     2019-03-08 15:57:16.180867+0800 demo[9895:195877] complete task 3

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

• 场景：

现在有4个任务，任务1、任务2、任务3、任务4. 任务3必须在任务2之后，任务4必须在前3个任务都执行完成后，才能执行，并且需要在主线程更新UI。

• 思路分析：

任务3必须在任务2之后，所以这两个必须串行执行，同时，任务2和3整体可以和任务1并行执行，最后，任务4只能等待前3个任务全部执行完成，才能执行。这里就可以用group快速实现场景需求。

-(void)disGroup{
    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_queue_t selfQueue = dispatch_queue_create("myQueue", 0);
    dispatch_group_t group = dispatch_group_create();
    dispatch_group_async(group, globalQueue, ^{
        debugLog(@"run task 1");//把一个任务异步提交到任务组
    });
    dispatch_group_async(group, selfQueue, ^{
        debugLog(@"run task 2");
    });
    dispatch_group_async(group, selfQueue, ^{
        debugLog(@"run task 3");
    });
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        debugLog(@"run task 4");
    });

     2019-03-11 13:33:45.094417+0800 demo[18795:1432061] run task 1
     2019-03-11 13:33:45.094431+0800 demo[18795:1432390] run task 2
     2019-03-11 13:33:45.094553+0800 demo[18795:1432390] run task 3
     2019-03-11 13:33:45.107656+0800 demo[18795:1431977] run task 4
}

 dispatch_group_enter(group),dispatch_group_leave(group)何时使用
 理论上讲，这两个方法其实就是：手动管理group关联的block的运行时状态（或计数），并且使用时必须保证进入和退出的group次数匹配。
 
 dispatch_group_async(group,queue,^{
    //......
 });
 dispatch_group_enter(group);
 
 dispatch_async(queue,^{
        //........
        dispatch_group_leave(group);
 });

 所以，这种用法和直接使用dispatch_group_notify 一定程度上是等价的

同步（sync）

全局并发队列	手动创建队列	主队列
p 没有开启新线程	p 没有开启新线程	p 没有开启新线程
p 串行执行任务	p 串行执行任务	p 串行执行任务

异步（async）

全局并发队列	手动创建队列	主队列
p 有开启新线程	p 有开启新线程	p 没有开启新线程
p 并发执行任务	p 串行执行任务	p 串行执行任务