iOS学习笔记74- 完整详解GCD系列（三）dispatch_group

原创Blog，转载请注明出处
http://blog.csdn.net/column/details/swift-gcd.html
一、dispatch_group
把一组任务提交到队列中，这些队列可以不相关，然后坚挺这组任务完成的事件。
几个用到的函数
1、dispatch_group_create创建一个调度任务组

[plain]  view plain  copy

1. func dispatch_group_create() -> dispatch_group_t!  

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

[plain]  view plain  copy

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

[plain]  view plain  copy

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 用来监听任务组事件的执行完毕

[plain]  view plain  copy

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则执行失败

[plain]  view plain  copy

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

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

[plain]  view plain  copy

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. }  

可以看到输出为

[plain]  view plain  copy

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如何使用

[plain]  view plain  copy

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. }  

输出

[plain]  view plain  copy

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。当然，也可以把下载的任务提交到异步队列中

[plain]  view plain  copy

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. }  

这样的话，输出是

[plain]  view plain  copy

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