完整详解GCD系列（三）dispatch_group

http://blog.csdn.net/hello_hwc/article/details/41409135

一、dispatch_group
把一组任务提交到队列中，这些队列可以不相关，然后坚挺这组任务完成的事件。
几个用到的函数
1、dispatch_group_create创建一个调度任务组

1. func dispatch_group_create() -> dispatch_group_t!

2、dispatch_group_async 把一个任务异步提交到任务组里

1. func dispatch_group_async(_ group: dispatch_group_t!,
2. _ queue: dispatch_queue_t!,
3. _ block: dispatch_block_t!)

参数： group 提交到的任务组，这个任务组的对象会一直持续到任务组执行完毕
        queue 提交到的队列，任务组里不同任务的队列可以不同
        block 提交的任务

3、dispatch_group_enter/dispatch_group_leave

1. func dispatch_group_enter(_ group: dispatch_group_t!)
2. func dispatch_group_leave(_ group: dispatch_group_t!)

这两个方法显示的讲任务组中的任务未执行完毕的任务数目加减1，这种方式用在不使用dispatch_group_async来提交任务，注意：这两个函数要配合使用，有enter要有leave，这样才能保证功能完整实现。也可以用这对函数来让一个闭包关联多个Group

4、dispatch_group_notify 用来监听任务组事件的执行完毕

1. func dispatch_group_notify(_ group: dispatch_group_t!,
2. _ queue: dispatch_queue_t!,
3. _ block: dispatch_block_t!)

参数： group监听的任务组
queue 执行完毕的这个闭包所在的队列
block 执行完毕所响应的任务
5、dispatch_group_wait 设置等待时间，在等待时间结束后，如果还没有执行完任务组，则返回。返回0代表执行成功，非0则执行失败

1. long dispatch_group_wait ( dispatch_group_t group, dispatch_time_t timeout );

二、完整的代码解析,模拟提交三个下载任务

1. class ViewController: UIViewController{
2. override func viewDidLoad(){
3. super.viewDidLoad()
4. var hwcGroup = dispatch_group_create()//创建group
5. var globalQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)//全局队列，这个队列为并行队列
6. var userCreateQueue =  dispatch_queue_create("com.test.helloHwc",DISPATCH_QUEUE_SERIAL)//创建一个用户队列，这个队列为串行队列
7. downLoadTask1(group: hwcGroup,queue: globalQueueDefault)
8. downLoadTask2(group: hwcGroup,queue: userCreateQueue)
9. downLoadTask3(group: hwcGroup,queue: userCreateQueue)
10. //letresult = dispatch_group_wait(hwcGroup,DISPATCH_TIME_FOREVER)
11. dispatch_group_notify(hwcGroup,dispatch_get_main_queue()){
12. NSLog("Group tasks are done")
13. }
14. println("Now viewDidLoad is done")
15. }
16. func downLoadTask1(#group:dispatch_group_t,queue:dispatch_queue_t){
17. dispatch_group_async(group,queue){
18. sleep(3)
19. NSLog("Task1 is done")
20. }
21. }
22. func downLoadTask2(#group:dispatch_group_t,queue:dispatch_queue_t){
23. dispatch_group_async(group,queue){
24. sleep(3)
25. NSLog("Task2 is done")
26. }
27. }
28. func downLoadTask3(#group:dispatch_group_t,queue:dispatch_queue_t){
29. dispatch_group_async(group,queue){
30. sleep(3)
31. NSLog("Task3 is done")
32. }
33. }
34. override func didReceiveMemoryWarning(){
35. super.didReceiveMemoryWarning()
36. }
37. }

可以看到输出为

1. Now viewDidLoad is done
2. Task2 is done
3. Task1 is done
4. Task3 is done
5. Group task is done

这里task1提交到全局队列中，task2和task3提交到用户穿件的串行队列中，所以task1和task2同时输出，task3在task2结束两秒后输出。

如果把注释那行取消，会等待一段时间，再返回，读者可以自己去试验下

三、关于如何使用dispatch_group_enter/dispatch_group_leave如何使用

1. <pre name="code" class="plain">class ViewController: UIViewController{
2. override func viewDidLoad(){
3. super.viewDidLoad()
4. var hwcGroup = dispatch_group_create()//创建group
5. var globalQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)//全局队列，这个队列为并行队列
6. for index:UInt32 in 1...3{
7. dispatch_group_enter(hwcGroup)//提交了一个任务，任务数目加1
8. manualDownLoad(index){
9. println("Task\(index) is done")
10. dispatch_group_leave(hwcGroup)//完成一个任务，任务数目减1
11. }
12. }
13. let result = dispatch_group_wait(hwcGroup,DISPATCH_TIME_FOREVER)//等待直到完成
14. dispatch_group_notify(hwcGroup,dispatch_get_main_queue()){
15. println("Group tasks are done")
16. }
17. println("Now viewDidLoad is done")
18. }
19. func manualDownLoad(num:UInt32,block:()->()){
20. println("Downloading task\(num)")
21. sleep(num)
22. block()
23. }
24. override func didReceiveMemoryWarning(){
25. super.didReceiveMemoryWarning()
26. }
27. }

输出

1. Downloading task1
2. Task1 is done
3. Downloading task2
4. Task2 is done
5. Downloading task3
6. Task3 is done
7. Now viewDidLoad is done
8. Group is done

可以看到，同步进行了下载，这里的任务是串行的，实际消耗时间9s。当然，也可以把下载的任务提交到异步队列中

1. class ViewController: UIViewController{
2. override func viewDidLoad(){
3. super.viewDidLoad()
4. var hwcGroup = dispatch_group_create()//创建group
5. var globalQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)//全局队列，这个队列为并行队列
6. for index:UInt32 in 1...3{
7. dispatch_group_enter(hwcGroup)//提交了一个任务，任务数目加1
8. manualDownLoad(index,queue:globalQueueDefault){
9. NSLog("Task\(index) is done")
10. dispatch_group_leave(hwcGroup)//完成一个任务，任务数目减1
11. }
12. }
13. dispatch_group_notify(hwcGroup,dispatch_get_main_queue()){
14. NSLog("Group tasks are done")
15. }
16. NSLog("Now viewDidLoad is done")
17. }
18. func manualDownLoad(num:UInt32,queue:dispatch_queue_t, block:()->()){
19. dispatch_async(queue){
20. NSLog("Downloading task\(num)")
21. sleep(num)
22. block()
23. }
24. }
25. override func didReceiveMemoryWarning(){
26. super.didReceiveMemoryWarning()
27. }
28. }

这样的话，输出是

1. Downloading task1
2. Downloading task2
3. Downloading task3
4. Now viewDidLoad is done
5. Task1 is done
6. Task2 is done
7. Task3 is done

由于三个模拟的下载任务是并行的，所以实际消耗时间3s