/////-------------注意----------------

這篇文章是在Swift 1.0時代寫的，已經不適合當前的語法。關於Swift最新版本的GCD，參見我的這篇部落格

• GCD精講
  

/////-------------注意----------------

一、dispatch_group
把一組任務提交到佇列中，這些佇列可以不相關，然後堅挺這組任務完成的事件。
幾個用到的函式
1、dispatch_group_create建立一個排程任務組

func dispatch_group_create() -> dispatch_group_t!

2、dispatch_group_async 把一個任務非同步提交到任務組裡

func dispatch_group_async(_ group: dispatch_group_t!,
                        _ queue: dispatch_queue_t!,
                        _ block: dispatch_block_t!)

引數：group提交到的任務組，這個任務組的物件會一直持續到任務組執行完畢
        queue提交到的佇列，任務組裡不同任務的佇列可以不同
        block提交的任務


3、dispatch_group_enter/dispatch_group_leave

func dispatch_group_enter(_ group: dispatch_group_t!)
func dispatch_group_leave(_ group: dispatch_group_t!)
 

這兩個方法顯示的講任務組中的任務未執行完畢的任務數目加減1，這種方式用在不使用dispatch_group_async來提交任務，注意：這兩個函式要配合使用，有enter要有leave，這樣才能保證功能完整實現。也可以用這對函式來讓一個閉包關聯多個Group

4、dispatch_group_notify 用來監聽任務組事件的執行完畢

func dispatch_group_notify(_ group: dispatch_group_t!,
                         _ queue: dispatch_queue_t!,
                         _ block: dispatch_block_t!)
 

引數：group監聽的任務組
queue執行完畢的這個閉包所在的佇列
block執行完畢所響應的任務
5、dispatch_group_wait 設定等待時間，在等待時間結束後，如果還沒有執行完任務組，則返回。返回0代表執行成功，非0則執行失敗

long dispatch_group_wait ( dispatch_group_t group, dispatch_time_t timeout );

二、完整的程式碼解析,模擬提交三個下載任務

class ViewController: UIViewController{    
    override func viewDidLoad(){    
        super.viewDidLoad()    
        var hwcGroup = dispatch_group_create()//建立group
	var globalQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)//全域性佇列，這個佇列為並行佇列
	var userCreateQueue =  dispatch_queue_create("com.test.helloHwc",DISPATCH_QUEUE_SERIAL)//建立一個使用者佇列，這個佇列為序列佇列
	downLoadTask1(group: hwcGroup,queue: globalQueueDefault)
	downLoadTask2(group: hwcGroup,queue: userCreateQueue)
	downLoadTask3(group: hwcGroup,queue: userCreateQueue)
	//letresult = dispatch_group_wait(hwcGroup,DISPATCH_TIME_FOREVER)
	dispatch_group_notify(hwcGroup,dispatch_get_main_queue()){
		NSLog("Group tasks are done")
	}
	println("Now viewDidLoad is done")
    }
    func downLoadTask1(#group:dispatch_group_t,queue:dispatch_queue_t){
	dispatch_group_async(group,queue){
		sleep(3)
		NSLog("Task1 is done")
	}
    }
   func downLoadTask2(#group:dispatch_group_t,queue:dispatch_queue_t){
	dispatch_group_async(group,queue){
		sleep(3)
		NSLog("Task2 is done")
	}
    }
   func downLoadTask3(#group:dispatch_group_t,queue:dispatch_queue_t){
	dispatch_group_async(group,queue){
		sleep(3)
		NSLog("Task3 is done")
	}
    }    
    override func didReceiveMemoryWarning(){    
        super.didReceiveMemoryWarning()    
    }    
}

可以看到輸出為

Now viewDidLoad is done
Task2 is done
Task1 is done
Task3 is done
Group task is done

這裡task1提交到全域性佇列中，task2和task3提交到使用者穿件的序列佇列中，所以task1和task2同時輸出，task3在task2結束兩秒後輸出。

如果把註釋那行取消，會等待一段時間，再返回，讀者可以自己去試驗下

三、關於如何使用dispatch_group_enter/dispatch_group_leave如何使用

<pre name="code" class="plain">class ViewController: UIViewController{    
    override func viewDidLoad(){    
        super.viewDidLoad()    
        var hwcGroup = dispatch_group_create()//建立group
	var globalQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)//全域性佇列，這個佇列為並行佇列
	for index:UInt32 in 1...3{
	     dispatch_group_enter(hwcGroup)//提交了一個任務，任務數目加1
		manualDownLoad(index){
		    println("Task\(index) is done")
			dispatch_group_leave(hwcGroup)//完成一個任務，任務數目減1
		}
	}
	let result = dispatch_group_wait(hwcGroup,DISPATCH_TIME_FOREVER)//等待直到完成
	dispatch_group_notify(hwcGroup,dispatch_get_main_queue()){
		println("Group tasks are done")
	}
	println("Now viewDidLoad is done")	
    }
    func manualDownLoad(num:UInt32,block:()->()){
	println("Downloading task\(num)")
	sleep(num)
	block()
    }  
    override func didReceiveMemoryWarning(){    
        super.didReceiveMemoryWarning()    
    }    
}

輸出

Downloading task1
Task1 is done
Downloading task2
Task2 is done
Downloading task3
Task3 is done
Now viewDidLoad is done
Group is done

可以看到，同步進行了下載，這裡的任務是序列的，實際消耗時間9s。當然，也可以把下載的任務提交到非同步佇列中

class ViewController: UIViewController{    
    override func viewDidLoad(){    
        super.viewDidLoad()    
        var hwcGroup = dispatch_group_create()//建立group
	var globalQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)//全域性佇列，這個佇列為並行佇列
	for index:UInt32 in 1...3{
	     dispatch_group_enter(hwcGroup)//提交了一個任務，任務數目加1
		manualDownLoad(index,queue:globalQueueDefault){
		    NSLog("Task\(index) is done")
			dispatch_group_leave(hwcGroup)//完成一個任務，任務數目減1
		}
	}
	dispatch_group_notify(hwcGroup,dispatch_get_main_queue()){
		NSLog("Group tasks are done")
	}
	NSLog("Now viewDidLoad is done")	
    }
    func manualDownLoad(num:UInt32,queue:dispatch_queue_t, block:()->()){
	dispatch_async(queue){
	NSLog("Downloading task\(num)")
	sleep(num)
	block()
        }
    }  
    override func didReceiveMemoryWarning(){    
        super.didReceiveMemoryWarning()    
    }    
}

這樣的話，輸出是

Downloading task1
Downloading task2
Downloading task3
Now viewDidLoad is done
Task1 is done
Task2 is done
Task3 is done

由於三個模擬的下載任務是並行的，所以實際消耗時間3s