iOS GCD執行緒之間的通訊

通過執行緒的依賴關係實現執行緒同步:

1、組佇列(dispatch_group_t)

         舉一個例子：使用者下載一個視訊，視訊很大，需要分成很多份進行下載，使用GCD應該如何實現？使用什麼佇列？

        使用Dispatch Group追加block到Global Group Queue，這些block如果全部執行完畢，就會執行通過dispatch_group_notify新增到主佇列中的block，進行視訊的合併處理。

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^{ /*載入視訊1 */ });
dispatch_group_async(group, queue, ^{ /*載入視訊2 */ });
dispatch_group_async(group, queue, ^{ /*載入視訊3 */ }); 
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 合併視訊… …
});

2、阻塞任務(dispatch_barrier_(a)sync)

         通過dispatch_barrier_async新增的操作會暫時阻塞當前佇列，即等待前面的併發操作都完成後執行該阻塞操作，待其完成後後面的併發操作才可繼續。可以將其比喻為一根霸道的獨木橋，是併發佇列中的一個併發障礙點，或者說中間瓶頸，臨時阻塞並獨佔。注意dispatch_barrier_async只有在併發佇列中才能起作用，在序列佇列中佇列本身就是獨木橋，將失去其意義。可見使用dispatch_barrier_async可以實現類似dispatch_group_t組排程的效果,同時主要的作用是避免資料競爭，高效訪問資料。

/* 建立併發佇列 */
dispatch_queue_t concurrentQueue = dispatch_queue_create("test.concurrent.queue", DISPATCH_QUEUE_CONCURRENT);
/* 新增兩個併發操作A和B，即A和B會併發執行 */
dispatch_async(concurrentQueue, ^(){
    NSLog(@"OperationA");
});
dispatch_async(concurrentQueue, ^(){
    NSLog(@"OperationB");
});
/* 新增barrier障礙操作，會等待前面的併發操作結束，並暫時阻塞後面的併發操作直到其完成 */
dispatch_barrier_async(concurrentQueue, ^(){
    NSLog(@"OperationBarrier!");
});
/* 繼續新增併發操作C和D，要等待barrier障礙操作結束才能開始 */
dispatch_async(concurrentQueue, ^(){
    NSLog(@"OperationC");
});
dispatch_async(concurrentQueue, ^(){
    NSLog(@"OperationD");
});

3、訊號量機制(dispatch_semaphore)

      訊號量機制主要是通過設定有限的資源數量來控制執行緒的最大併發數量以及阻塞執行緒實現執行緒同步等。

      GCD中使用訊號量需要用到三個函式：

• dispatch_semaphore_create用來建立一個semaphore訊號量並設定初始訊號量的值；
• dispatch_semaphore_signal傳送一個訊號讓訊號量增加1（對應PV操作的V操作）；
• dispatch_semaphore_wait等待訊號使訊號量減1（對應PV操作的P操作）；

         那麼如何通過訊號量來實現執行緒同步呢？下面介紹使用GCD訊號量來實現任務間的依賴和最大併發任務數量的控制。使用訊號量實現任務2依賴於任務1，即任務2要等待任務1結束才開始執行:方法很簡單，建立訊號量並初始化為0，讓任務2執行前等待訊號，實現對任務2的阻塞。然後在任務1完成後再傳送訊號，從而任務2獲得訊號開始執行。需要注意的是這裡任務1和2都是非同步提交的，如果沒有訊號量的阻塞，任務2是不會等待任務1的,實際上這裡使用訊號量實現了兩個任務的同步。

        通過訊號量控制最大併發數量的方法為：建立訊號量並初始化訊號量為想要控制的最大併發數量，例如想要保證最大併發數為5，則訊號量初始化為5。然後在每個新任務執行前進行P操作，等待訊號使訊號量減1；每個任務結束後進行V操作，傳送訊號使訊號量加1。這樣即可保證訊號量始終在5以內，當前最多也只有5個以內的任務在併發執行。

/* 建立一個訊號量 */
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);

/* 任務1 */
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    /* 耗時任務1 */
    NSLog(@"任務1開始");
    [NSThread sleepForTimeInterval:3];
    NSLog(@"任務1結束");
    /* 任務1結束，傳送訊號告訴任務2可以開始了 */
    dispatch_semaphore_signal(semaphore);
});

/* 任務2 */
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    /* 等待任務1結束獲得訊號量, 無限等待 */
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    /* 如果獲得訊號量則開始任務2 */
    NSLog(@"任務2開始");
    [NSThread sleepForTimeInterval:3];
    NSLog(@"任務2結束");
});
[NSThread sleepForTimeInterval:10];



/* 建立一個訊號量並初始化為5 */
dispatch_semaphore_t semaphore = dispatch_semaphore_create(5);

/* 模擬1000個等待執行的任務，通過訊號量控制最大併發任務數量為5 */
for (int i = 0; i < 1000; i++) {
    /* 任務i */
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        /* 耗時任務1，執行前等待訊號使訊號量減1 */
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"任務%d開始", i);
        [NSThread sleepForTimeInterval:10];
        NSLog(@"任務%d結束", i);
        /* 任務i結束，傳送訊號釋放一個資源 */
        dispatch_semaphore_signal(semaphore);
    });
}
[NSThread sleepForTimeInterval:1000];