iOS 多線程：『GCD』詳盡總結

原創 行走少年郎 2020-02-23 18:37
 
1877784-da5bde1448673a18.png
 

再次感謝大家對這篇文章的喜歡和支持。爲了更好的讓大家瞭解 iOS 多線程，以及 GCD 的相關知識，我第三次對這篇文章進行了梳理，修改了 GCD 不同組合方式區別的相關總結，以及 隊列、任務以及線程之間關係的形象理解。

本文用來介紹 iOS 多線程中 GCD 的相關知識以及使用方法。這大概是史上最詳細、清晰的關於 GCD 的詳細講解 + 總結 的文章了。通過本文，您將瞭解到：
1. GCD 簡介
2. GCD 任務和隊列
3. GCD 的使用步驟
4. GCD 的基本使用（六種組合不同區別，隊列嵌套情況區別，相互關係形象理解）
5. GCD 線程間的通信
6. GCD 的其他方法（柵欄方法：dispatch_barrier_async、延時執行方法：dispatch_after、一次性代碼（只執行一次）：dispatch_once、快速迭代方法：dispatch_apply、隊列組：dispatch_group、信號量：dispatch_semaphore）

文中 Demo 我已放在了 Github 上，Demo 鏈接：傳送門

1. GCD 簡介

什麼是 『GCD』 ？我們先來看看百度百科的解釋簡單瞭解下相關概念。

引自 百度百科
Grand Central Dispatch（GCD） 是 Apple 開發的一個多核編程的較新的解決方法。它主要用於優化應用程序以支持多核處理器以及其他對稱多處理系統。它是一個在線程池模式的基礎上執行的併發任務。在 Mac OS X 10.6 雪豹中首次推出，也可在 iOS 4 及以上版本使用。

那爲什麼我們要使用 GCD 呢？

因爲使用 GCD 有很多好處啊，具體如下：

  • GCD 可用於多核的並行運算；
  • GCD 會自動利用更多的 CPU 內核（比如雙核、四核）；
  • GCD 會自動管理線程的生命週期（創建線程、調度任務、銷燬線程）；
  • 程序員只需要告訴 GCD 想要執行什麼任務，不需要編寫任何線程管理代碼。

GCD 擁有以上這麼多的好處，而且在多線程中處於舉足輕重的地位。那麼我們就很有必要系統地學習一下 GCD 的使用方法。

2. GCD 任務和隊列

學習 GCD 之前，先來了解 GCD 中兩個核心概念：『任務』 和 『隊列』。

任務：就是執行操作的意思，換句話說就是你在線程中執行的那段代碼。在 GCD 中是放在 block 中的。執行任務有兩種方式：『同步執行』 和 『異步執行』。兩者的主要區別是：是否等待隊列的任務執行結束，以及是否具備開啓新線程的能力。

  • 同步執行（sync）：
    • 同步添加任務到指定的隊列中，在添加的任務執行結束之前，會一直等待，直到隊列裏面的任務完成之後再繼續執行。
    • 只能在當前線程中執行任務，不具備開啓新線程的能力。
  • 異步執行（async）：
    • 異步添加任務到指定的隊列中，它不會做任何等待，可以繼續執行任務。
    • 可以在新的線程中執行任務，具備開啓新線程的能力。

舉個簡單例子：你要打電話給小明和小白。
『同步執行』 就是：你打電話給小明的時候，不能同時打給小白。只有等到給小明打完了，才能打給小白（等待任務執行結束）。而且只能用當前的電話（不具備開啓新線程的能力）。
『異步執行』 就是：你打電話給小明的時候，不用等着和小明通話結束（不用等待任務執行結束），還能同時給小白打電話。而且除了當前電話，你還可以使用其他一個或多個電話（具備開啓新線程的能力）。

注意：異步執行（async）雖然具有開啓新線程的能力，但是並不一定開啓新線程。這跟任務所指定的隊列類型有關（下面會講）。

隊列（Dispatch Queue）：這裏的隊列指執行任務的等待隊列，即用來存放任務的隊列。隊列是一種特殊的線性表，採用 FIFO（先進先出）的原則，即新任務總是被插入到隊列的末尾，而讀取任務的時候總是從隊列的頭部開始讀取。每讀取一個任務，則從隊列中釋放一個任務。隊列的結構可參考下圖：

 
1877784-01267bd211719167.png
隊列（Dispatch Queue）.png

 

在 GCD 中有兩種隊列：『串行隊列』 和 『併發隊列』。兩者都符合 FIFO（先進先出）的原則。兩者的主要區別是：執行順序不同，以及開啓線程數不同。

  • 串行隊列（Serial Dispatch Queue）：
    • 每次只有一個任務被執行。讓任務一個接着一個地執行。（只開啓一個線程，一個任務執行完畢後，再執行下一個任務）
  • 併發隊列（Concurrent Dispatch Queue）：
    • 可以讓多個任務併發（同時）執行。（可以開啓多個線程，並且同時執行任務）

注意：併發隊列 的併發功能只有在異步（dispatch_async）方法下才有效。

兩者具體區別如下兩圖所示：

 
1877784-4faca27116209f35.png
串行隊列（Serial Dispatch Queue）.png
 
1877784-97f3931d1b187b11.png
併發隊列（Concurrent Dispatch Queue）.png

3. GCD 的使用步驟

GCD 的使用步驟其實很簡單，只有兩步：

  1. 創建一個隊列（串行隊列或併發隊列）；
  2. 將任務追加到任務的等待隊列中，然後系統就會根據任務類型執行任務（同步執行或異步執行）。

下邊來看看隊列的創建方法 / 獲取方法，以及任務的創建方法。

3.1 隊列的創建方法 / 獲取方法

  • 可以使用 dispatch_queue_create 方法來創建隊列。該方法需要傳入兩個參數：
    • 第一個參數表示隊列的唯一標識符，用於 DEBUG，可爲空。隊列的名稱推薦使用應用程序 ID 這種逆序全程域名。
    • 第二個參數用來識別是串行隊列還是併發隊列。DISPATCH_QUEUE_SERIAL 表示串行隊列，DISPATCH_QUEUE_CONCURRENT 表示併發隊列。
// 串行隊列的創建方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
// 併發隊列的創建方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
  • 對於串行隊列，GCD 默認提供了：『主隊列（Main Dispatch Queue）』。
    • 所有放在主隊列中的任務，都會放到主線程中執行。
    • 可使用 dispatch_get_main_queue() 方法獲得主隊列。

注意：主隊列其實並不特殊。 主隊列的實質上就是一個普通的串行隊列，只是因爲默認情況下，當前代碼是放在主隊列中的，然後主隊列中的代碼，有都會放到主線程中去執行，所以才造成了主隊列特殊的現象。

// 主隊列的獲取方法
dispatch_queue_t queue = dispatch_get_main_queue();
  • 對於併發隊列，GCD 默認提供了 『全局併發隊列（Global Dispatch Queue）』。
    • 可以使用 dispatch_get_global_queue 方法來獲取全局併發隊列。需要傳入兩個參數。第一個參數表示隊列優先級，一般用 DISPATCH_QUEUE_PRIORITY_DEFAULT。第二個參數暫時沒用，用 0 即可。
// 全局併發隊列的獲取方法
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

3.2 任務的創建方法

GCD 提供了同步執行任務的創建方法 dispatch_sync 和異步執行任務創建方法 dispatch_async。

// 同步執行任務創建方法
dispatch_sync(queue, ^{
    // 這裏放同步執行任務代碼
});
// 異步執行任務創建方法
dispatch_async(queue, ^{
    // 這裏放異步執行任務代碼
});

雖然使用 GCD 只需兩步，但是既然我們有兩種隊列（串行隊列 / 併發隊列），兩種任務執行方式（同步執行 / 異步執行），那麼我們就有了四種不同的組合方式。這四種不同的組合方式是：

  1. 同步執行 + 併發隊列
  2. 異步執行 + 併發隊列
  3. 同步執行 + 串行隊列
  4. 異步執行 + 串行隊列

實際上，剛纔還說了兩種默認隊列：全局併發隊列、主隊列。全局併發隊列可以作爲普通併發隊列來使用。但是當前代碼默認放在主隊列中，所以主隊列很有必要專門來研究一下，所以我們就又多了兩種組合方式。這樣就有六種不同的組合方式了。

  1. 同步執行 + 主隊列
  2. 異步執行 + 主隊列

那麼這幾種不同組合方式各有什麼區別呢？

這裏我們先上結論，後面再來詳細講解。你可以直接查看 3.3 任務和隊列不同組合方式的區別 中的表格結果，然後跳過 4. GCD的基本使用 繼續往後看。

3.3 任務和隊列不同組合方式的區別

我們先來考慮最基本的使用，也就是當前線程爲 『主線程』 的環境下，『不同隊列』+『不同任務』 簡單組合使用的不同區別。暫時不考慮 『隊列中嵌套隊列』 的這種複雜情況。

『主線程』中，『不同隊列』+『不同任務』簡單組合的區別：

區別 併發隊列 串行隊列 主隊列
同步（sync） 沒有開啓新線程，串行執行任務 沒有開啓新線程，串行執行任務 死鎖卡住不執行
異步（async） 有開啓新線程，併發執行任務 有開啓新線程（1條），串行執行任務 沒有開啓新線程，串行執行任務

注意：從上邊可看出： 『主線程』 中調用 『主隊列』+『同步執行』 會導致死鎖問題。
這是因爲 主隊列中追加的同步任務 和 主線程本身的任務 兩者之間相互等待，阻塞了 『主隊列』，最終造成了主隊列所在的線程（主線程）死鎖問題。
而如果我們在 『其他線程』 調用 『主隊列』+『同步執行』，則不會阻塞 『主隊列』，自然也不會造成死鎖問題。最終的結果是：不會開啓新線程，串行執行任務。

3.4 隊列嵌套情況下，不同組合方式區別

除了上邊提到的『主線程』中調用『主隊列』+『同步執行』會導致死鎖問題。實際在使用『串行隊列』的時候，也可能出現阻塞『串行隊列』所在線程的情況發生，從而造成死鎖問題。這種情況多見於同一個串行隊列的嵌套使用。

比如下面代碼這樣：在『異步執行』+『串行隊列』的任務中，又嵌套了『當前的串行隊列』，然後進行『同步執行』。

dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{    // 異步執行 + 串行隊列
    dispatch_sync(queue, ^{  // 同步執行 + 當前串行隊列
        // 追加任務 1
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當前線程
    });
});

執行上面的代碼會導致 串行隊列中追加的任務 和 串行隊列中原有的任務 兩者之間相互等待，阻塞了『串行隊列』，最終造成了串行隊列所在的線程（子線程）死鎖問題。

主隊列造成死鎖也是基於這個原因，所以，這也進一步說明了主隊列其實並不特殊。

關於 『隊列中嵌套隊列』這種複雜情況，這裏也簡單做一個總結。不過這裏只考慮同一個隊列的嵌套情況，關於多個隊列的相互嵌套情況還請自行研究，或者等我最新的文章發佈。

『不同隊列』+『不同任務』 組合，以及 『隊列中嵌套隊列』 使用的區別：

區別 『異步執行+併發隊列』嵌套『同一個併發隊列』 『同步執行+併發隊列』嵌套『同一個併發隊列』 『異步執行+串行隊列』嵌套『同一個串行隊列』 『同步執行+串行隊列』嵌套『同一個串行隊列』
同步（sync） 沒有開啓新的線程，串行執行任務 沒有開啓新線程，串行執行任務 死鎖卡住不執行 死鎖卡住不執行
異步（async） 有開啓新線程，併發執行任務 有開啓新線程，併發執行任務 有開啓新線程（1 條），串行執行任務 有開啓新線程（1 條），串行執行任務

好了，關於『不同隊列』+『不同任務』 組合不同區別總結就到這裏。

3.5 關於不同隊列和不同任務的形象理解

因爲前一段時間看到了有朋友留言說對 異步執行 和 併發隊列 中創建線程能力有所不理解，我覺得這個問題的確很容易造成困惑，所以很值得拿來專門分析一下。

他的問題：

在 異步 + 併發 中的解釋：
（異步執行具備開啓新線程的能力。且併發隊列可開啓多個線程，同時執行多個任務）

以及 同步 + 併發 中的解釋：
（雖然併發隊列可以開啓多個線程，並且同時執行多個任務。但是因爲本身不能創建新線程，只有當前線程這一個線程（同步任務不具備開啓新線程的能力）

這個地方看起來有點疑惑，你兩個地方分別提到：異步執行開啓新線程，併發隊列也可以開啓新線程，想請教下，你的意思是隻有任務才擁有創建新線程的能力，而隊列只有開啓線程的能力，並不能創建線程 ？這二者是這樣的關聯嗎？

關於這個問題，我想做一個很形象的類比，來幫助大家對 隊列、任務 以及 線程 之間關係的理解。

假設現在有 5 個人要穿過一道門禁，這道門禁總共有 10 個入口，管理員可以決定同一時間打開幾個入口，可以決定同一時間讓一個人單獨通過還是多個人一起通過。不過默認情況下，管理員只開啓一個入口，且一個通道一次只能通過一個人。

  • 這個故事裏，人好比是 任務，管理員好比是 系統，入口則代表 線程。

    • 5 個人表示有 5 個任務，10 個入口代表 10 條線程。
    • 串行隊列 好比是 5 個人排成一支長隊。
    • 併發隊列 好比是 5 個人排成多支隊伍，比如 2 隊，或者 3 隊。
    • 同步任務 好比是管理員只開啓了一個入口（當前線程）。
    • 異步任務 好比是管理員同時開啓了多個入口（當前線程 + 新開的線程）。

  • 『異步執行 + 併發隊列』 可以理解爲：現在管理員開啓了多個入口（比如 3 個入口），5 個人排成了多支隊伍（比如 3 支隊伍），這樣這 5 個人就可以 3 個人同時一起穿過門禁了。

  • 『同步執行 + 併發隊列』 可以理解爲：現在管理員只開啓了 1 個入口，5 個人排成了多支隊伍。雖然這 5 個人排成了多支隊伍，但是隻開了 1 個入口啊，這 5 個人雖然都想快點過去，但是 1 個入口一次只能過 1 個人，所以大家就只好一個接一個走過去了，表現的結果就是：順次通過入口。

  • 換成 GCD 裏的語言就是說：

    • 『異步執行 + 併發隊列』就是：系統開啓了多個線程（主線程+其他子線程），任務可以多個同時運行。
    • 『同步執行 + 併發隊列』就是：系統只默認開啓了一個主線程，沒有開啓子線程，雖然任務處於併發隊列中，但也只能一個接一個執行了。

下邊我們來研究一下上邊提到的六種簡單組合方式的使用方法。

4. GCD 的基本使用

先來講講併發隊列的兩種執行方式。

4.1 同步執行 + 併發隊列

  • 在當前線程中執行任務，不會開啓新線程，執行完一個任務，再執行下一個任務。
/**
 * 同步執行 + 併發隊列
 * 特點：在當前線程中執行任務，不會開啓新線程，執行完一個任務，再執行下一個任務。
 */
- (void)syncConcurrent {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當前線程
    NSLog(@"syncConcurrent---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_sync(queue, ^{
        // 追加任務 1
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    dispatch_sync(queue, ^{
        // 追加任務 2
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    dispatch_sync(queue, ^{
        // 追加任務 3
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    NSLog(@"syncConcurrent---end");
}

輸出結果：
2019-08-08 14:32:53.542816+0800 YSC-GCD-demo[16332:4171500] currentThread---<NSThread: 0x600002326940>{number = 1, name = main}
2019-08-08 14:32:53.542964+0800 YSC-GCD-demo[16332:4171500] syncConcurrent---begin
2019-08-08 14:32:55.544329+0800 YSC-GCD-demo[16332:4171500] 1---<NSThread: 0x600002326940>{number = 1, name = main}
2019-08-08 14:32:57.545779+0800 YSC-GCD-demo[16332:4171500] 2---<NSThread: 0x600002326940>{number = 1, name = main}
2019-08-08 14:32:59.547154+0800 YSC-GCD-demo[16332:4171500] 3---<NSThread: 0x600002326940>{number = 1, name = main}
2019-08-08 14:32:59.547365+0800 YSC-GCD-demo[16332:4171500] syncConcurrent---end

從 同步執行 + 併發隊列 中可看到：

  • 所有任務都是在當前線程（主線程）中執行的，沒有開啓新的線程（同步執行不具備開啓新線程的能力）。
  • 所有任務都在打印的 syncConcurrent---begin 和 syncConcurrent---end 之間執行的（同步任務 需要等待隊列的任務執行結束）。
  • 任務按順序執行的。按順序執行的原因：雖然 併發隊列 可以開啓多個線程，並且同時執行多個任務。但是因爲本身不能創建新線程，只有當前線程這一個線程（同步任務 不具備開啓新線程的能力），所以也就不存在併發。而且當前線程只有等待當前隊列中正在執行的任務執行完畢之後，才能繼續接着執行下面的操作（同步任務 需要等待隊列的任務執行結束）。所以任務只能一個接一個按順序執行，不能同時被執行。

4.2 異步執行 + 併發隊列

  • 可以開啓多個線程，任務交替（同時）執行。
/**
 * 異步執行 + 併發隊列
 * 特點：可以開啓多個線程，任務交替（同時）執行。
 */
- (void)asyncConcurrent {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當前線程
    NSLog(@"asyncConcurrent---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(queue, ^{
        // 追加任務 1
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    dispatch_async(queue, ^{
        // 追加任務 2
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    dispatch_async(queue, ^{
        // 追加任務 3
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    NSLog(@"asyncConcurrent---end");
}

輸出結果：
2019-08-08 14:36:37.747966+0800 YSC-GCD-demo[17232:4187114] currentThread---<NSThread: 0x60000206d380>{number = 1, name = main}
2019-08-08 14:36:37.748150+0800 YSC-GCD-demo[17232:4187114] asyncConcurrent---begin
2019-08-08 14:36:37.748279+0800 YSC-GCD-demo[17232:4187114] asyncConcurrent---end
2019-08-08 14:36:39.752523+0800 YSC-GCD-demo[17232:4187204] 2---<NSThread: 0x600002010980>{number = 3, name = (null)}
2019-08-08 14:36:39.752527+0800 YSC-GCD-demo[17232:4187202] 3---<NSThread: 0x600002018480>{number = 5, name = (null)}
2019-08-08 14:36:39.752527+0800 YSC-GCD-demo[17232:4187203] 1---<NSThread: 0x600002023400>{number = 4, name = (null)}

在 異步執行 + 併發隊列 中可以看出：

  • 除了當前線程（主線程），系統又開啓了 3 個線程，並且任務是交替/同時執行的。（異步執行 具備開啓新線程的能力。且 併發隊列 可開啓多個線程，同時執行多個任務）。
  • 所有任務是在打印的 syncConcurrent---begin 和 syncConcurrent---end 之後才執行的。說明當前線程沒有等待，而是直接開啓了新線程，在新線程中執行任務（異步執行 不做等待，可以繼續執行任務）。

接下來再來講講串行隊列的兩種執行方式。

4.3 同步執行 + 串行隊列

  • 不會開啓新線程，在當前線程執行任務。任務是串行的，執行完一個任務，再執行下一個任務。
/**
 * 同步執行 + 串行隊列
 * 特點：不會開啓新線程，在當前線程執行任務。任務是串行的，執行完一個任務，再執行下一個任務。
 */
- (void)syncSerial {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當前線程
    NSLog(@"syncSerial---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
    
    dispatch_sync(queue, ^{
        // 追加任務 1
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當前線程
    });
    dispatch_sync(queue, ^{
        // 追加任務 2
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印當前線程
    });
    dispatch_sync(queue, ^{
        // 追加任務 3
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    NSLog(@"syncSerial---end");
}

輸出結果爲：
2019-08-08 14:39:31.366815+0800 YSC-GCD-demo[17285:4197645] currentThread---<NSThread: 0x600001b5e940>{number = 1, name = main}
2019-08-08 14:39:31.366952+0800 YSC-GCD-demo[17285:4197645] syncSerial---begin
2019-08-08 14:39:33.368256+0800 YSC-GCD-demo[17285:4197645] 1---<NSThread: 0x600001b5e940>{number = 1, name = main}
2019-08-08 14:39:35.369661+0800 YSC-GCD-demo[17285:4197645] 2---<NSThread: 0x600001b5e940>{number = 1, name = main}
2019-08-08 14:39:37.370991+0800 YSC-GCD-demo[17285:4197645] 3---<NSThread: 0x600001b5e940>{number = 1, name = main}
2019-08-08 14:39:37.371192+0800 YSC-GCD-demo[17285:4197645] syncSerial---end

在 同步執行 + 串行隊列 可以看到：

  • 所有任務都是在當前線程（主線程）中執行的，並沒有開啓新的線程（同步執行 不具備開啓新線程的能力）。
  • 所有任務都在打印的 syncConcurrent---begin 和 syncConcurrent---end 之間執行（同步任務 需要等待隊列的任務執行結束）。
  • 任務是按順序執行的（串行隊列 每次只有一個任務被執行，任務一個接一個按順序執行）。

4.4 異步執行 + 串行隊列

  • 會開啓新線程，但是因爲任務是串行的，執行完一個任務，再執行下一個任務
/**
 * 異步執行 + 串行隊列
 * 特點：會開啓新線程，但是因爲任務是串行的，執行完一個任務，再執行下一個任務。
 */
- (void)asyncSerial {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當前線程
    NSLog(@"asyncSerial---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
    
    dispatch_async(queue, ^{
        // 追加任務 1
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當前線程
    });
    dispatch_async(queue, ^{
        // 追加任務 2
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印當前線程
    });
    dispatch_async(queue, ^{
        // 追加任務 3
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    NSLog(@"asyncSerial---end");
}

輸出結果爲：
2019-08-08 14:40:53.944502+0800 YSC-GCD-demo[17313:4203018] currentThread---<NSThread: 0x6000015da940>{number = 1, name = main}
2019-08-08 14:40:53.944615+0800 YSC-GCD-demo[17313:4203018] asyncSerial---begin
2019-08-08 14:40:53.944710+0800 YSC-GCD-demo[17313:4203018] asyncSerial---end
2019-08-08 14:40:55.947709+0800 YSC-GCD-demo[17313:4203079] 1---<NSThread: 0x6000015a0840>{number = 3, name = (null)}
2019-08-08 14:40:57.952453+0800 YSC-GCD-demo[17313:4203079] 2---<NSThread: 0x6000015a0840>{number = 3, name = (null)}
2019-08-08 14:40:59.952943+0800 YSC-GCD-demo[17313:4203079] 3---<NSThread: 0x6000015a0840>{number = 3, name = (null)}

在 異步執行 + 串行隊列 可以看到：

  • 開啓了一條新線程（異步執行 具備開啓新線程的能力，串行隊列 只開啓一個線程）。
  • 所有任務是在打印的 syncConcurrent---begin 和 syncConcurrent---end 之後纔開始執行的（異步執行 不會做任何等待，可以繼續執行任務）。
  • 任務是按順序執行的（串行隊列 每次只有一個任務被執行，任務一個接一個按順序執行）。

下邊講講剛纔我們提到過的：主隊列。

  • 主隊列：GCD 默認提供的 串行隊列。
    • 默認情況下，平常所寫代碼是直接放在主隊列中的。
    • 所有放在主隊列中的任務，都會放到主線程中執行。
    • 可使用 dispatch_get_main_queue() 獲得主隊列。

我們再來看看主隊列的兩種組合方式。

4.5 同步執行 + 主隊列

同步執行 + 主隊列 在不同線程中調用結果也是不一樣，在主線程中調用會發生死鎖問題，而在其他線程中調用則不會。

4.5.1 在主線程中調用 『同步執行 + 主隊列』

  • 互相等待卡住不可行
/**
 * 同步執行 + 主隊列
 * 特點(主線程調用)：互等卡主不執行。
 * 特點(其他線程調用)：不會開啓新線程，執行完一個任務，再執行下一個任務。
 */
- (void)syncMain {
    
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當前線程
    NSLog(@"syncMain---begin");
    
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    dispatch_sync(queue, ^{
        // 追加任務 1
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    dispatch_sync(queue, ^{
        // 追加任務 2
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    dispatch_sync(queue, ^{
        // 追加任務 3
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    NSLog(@"syncMain---end");
}

輸出結果
2019-08-08 14:43:58.062376+0800 YSC-GCD-demo[17371:4213562] currentThread---<NSThread: 0x6000026e2940>{number = 1, name = main}
2019-08-08 14:43:58.062518+0800 YSC-GCD-demo[17371:4213562] syncMain---begin
(lldb)

在主線程中使用 同步執行 + 主隊列 可以驚奇的發現：

  • 追加到主線程的任務 1、任務 2、任務 3 都不再執行了，而且 syncMain---end 也沒有打印，在 XCode 9 及以上版本上還會直接報崩潰。這是爲什麼呢？

這是因爲我們在主線程中執行 syncMain 方法，相當於把 syncMain 任務放到了主線程的隊列中。而 同步執行 會等待當前隊列中的任務執行完畢，纔會接着執行。那麼當我們把 任務 1 追加到主隊列中，任務 1 就在等待主線程處理完 syncMain 任務。而syncMain 任務需要等待 任務 1 執行完畢，才能接着執行。

那麼，現在的情況就是 syncMain 任務和 任務 1 都在等對方執行完畢。這樣大家互相等待，所以就卡住了，所以我們的任務執行不了，而且 syncMain---end 也沒有打印。

要是如果不在主線程中調用，而在其他線程中調用會如何呢？

4.5.2 在其他線程中調用『同步執行 + 主隊列』

  • 不會開啓新線程，執行完一個任務，再執行下一個任務
// 使用 NSThread 的 detachNewThreadSelector 方法會創建線程，並自動啓動線程執行 selector 任務
[NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];

輸出結果：
2019-08-08 14:51:38.137978+0800 YSC-GCD-demo[17482:4237818] currentThread---<NSThread: 0x600001dd6c00>{number = 3, name = (null)}
2019-08-08 14:51:38.138159+0800 YSC-GCD-demo[17482:4237818] syncMain---begin
2019-08-08 14:51:40.149065+0800 YSC-GCD-demo[17482:4237594] 1---<NSThread: 0x600001d8d380>{number = 1, name = main}
2019-08-08 14:51:42.151104+0800 YSC-GCD-demo[17482:4237594] 2---<NSThread: 0x600001d8d380>{number = 1, name = main}
2019-08-08 14:51:44.152583+0800 YSC-GCD-demo[17482:4237594] 3---<NSThread: 0x600001d8d380>{number = 1, name = main}
2019-08-08 14:51:44.152767+0800 YSC-GCD-demo[17482:4237818] syncMain---end

在其他線程中使用 同步執行 + 主隊列 可看到：

  • 所有任務都是在主線程（非當前線程）中執行的，沒有開啓新的線程（所有放在主隊列中的任務，都會放到主線程中執行）。
  • 所有任務都在打印的 syncConcurrent---begin 和 syncConcurrent---end 之間執行（同步任務 需要等待隊列的任務執行結束）。
  • 任務是按順序執行的（主隊列是 串行隊列，每次只有一個任務被執行，任務一個接一個按順序執行）。

爲什麼現在就不會卡住了呢？

因爲syncMain 任務 放到了其他線程裏，而 任務 1、任務 2、任務3 都在追加到主隊列中，這三個任務都會在主線程中執行。syncMain 任務 在其他線程中執行到追加 任務 1 到主隊列中，因爲主隊列現在沒有正在執行的任務，所以，會直接執行主隊列的 任務1，等 任務1 執行完畢，再接着執行 任務 2、任務 3。所以這裏不會卡住線程，也就不會造成死鎖問題。

4.6 異步執行 + 主隊列

  • 只在主線程中執行任務，執行完一個任務，再執行下一個任務。
/**
 * 異步執行 + 主隊列
 * 特點：只在主線程中執行任務，執行完一個任務，再執行下一個任務
 */
- (void)asyncMain {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當前線程
    NSLog(@"asyncMain---begin");
    
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    dispatch_async(queue, ^{
        // 追加任務 1
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    dispatch_async(queue, ^{
        // 追加任務 2
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    dispatch_async(queue, ^{
        // 追加任務 3
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    NSLog(@"asyncMain---end");
}

輸出結果：
2019-08-08 14:53:27.023091+0800 YSC-GCD-demo[17521:4243690] currentThread---<NSThread: 0x6000022a1380>{number = 1, name = main}
2019-08-08 14:53:27.023247+0800 YSC-GCD-demo[17521:4243690] asyncMain---begin
2019-08-08 14:53:27.023399+0800 YSC-GCD-demo[17521:4243690] asyncMain---end
2019-08-08 14:53:29.035565+0800 YSC-GCD-demo[17521:4243690] 1---<NSThread: 0x6000022a1380>{number = 1, name = main}
2019-08-08 14:53:31.036565+0800 YSC-GCD-demo[17521:4243690] 2---<NSThread: 0x6000022a1380>{number = 1, name = main}
2019-08-08 14:53:33.037092+0800 YSC-GCD-demo[17521:4243690] 3---<NSThread: 0x6000022a1380>{number = 1, name = main}

在 異步執行 + 主隊列 可以看到：

  • 所有任務都是在當前線程（主線程）中執行的，並沒有開啓新的線程（雖然 異步執行 具備開啓線程的能力，但因爲是主隊列，所以所有任務都在主線程中）。
  • 所有任務是在打印的 syncConcurrent---begin 和 syncConcurrent---end 之後纔開始執行的（異步執行不會做任何等待，可以繼續執行任務）。
  • 任務是按順序執行的（因爲主隊列是 串行隊列，每次只有一個任務被執行，任務一個接一個按順序執行）。

弄懂了難理解、繞來繞去的『不同隊列』+『不同任務』使用區別之後，我們來學習一個簡單的東西：5. GCD 線程間的通信。

5. GCD 線程間的通信

在 iOS 開發過程中，我們一般在主線程裏邊進行 UI 刷新，例如：點擊、滾動、拖拽等事件。我們通常把一些耗時的操作放在其他線程，比如說圖片下載、文件上傳等耗時操作。而當我們有時候在其他線程完成了耗時操作時，需要回到主線程，那麼就用到了線程之間的通訊。

/**
 * 線程間通信
 */
- (void)communication {
    // 獲取全局併發隊列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    // 獲取主隊列
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    
    dispatch_async(queue, ^{
        // 異步追加任務 1
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當前線程
        
        // 回到主線程
        dispatch_async(mainQueue, ^{
            // 追加在主線程中執行的任務
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印當前線程
        });
    });
}

輸出結果：
2019-08-08 14:56:22.973318+0800 YSC-GCD-demo[17573:4253201] 1---<NSThread: 0x600001846080>{number = 3, name = (null)}
2019-08-08 14:56:24.973902+0800 YSC-GCD-demo[17573:4253108] 2---<NSThread: 0x60000181e940>{number = 1, name = main}

  • 可以看到在其他線程中先執行任務，執行完了之後回到主線程執行主線程的相應操作。

6. GCD 的其他方法

6.1 GCD 柵欄方法：dispatch_barrier_async

  • 我們有時需要異步執行兩組操作，而且第一組操作執行完之後，才能開始執行第二組操作。這樣我們就需要一個相當於 柵欄 一樣的一個方法將兩組異步執行的操作組給分割起來，當然這裏的操作組裏可以包含一個或多個任務。這就需要用到dispatch_barrier_async 方法在兩個操作組間形成柵欄。
    dispatch_barrier_async 方法會等待前邊追加到併發隊列中的任務全部執行完畢之後，再將指定的任務追加到該異步隊列中。然後在 dispatch_barrier_async 方法追加的任務執行完畢之後，異步隊列才恢復爲一般動作，接着追加任務到該異步隊列並開始執行。具體如下圖所示：
     
    1877784-4d6d77fafd3ad007.png
    dispatch_barrier_async.png
/**
 * 柵欄方法 dispatch_barrier_async
 */
- (void)barrier {
    dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(queue, ^{
        // 追加任務 1
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當前線程
    });
    dispatch_async(queue, ^{
        // 追加任務 2
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    dispatch_barrier_async(queue, ^{
        // 追加任務 barrier
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"barrier---%@",[NSThread currentThread]);// 打印當前線程
    });
    
    dispatch_async(queue, ^{
        // 追加任務 3
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印當前線程
    });
    dispatch_async(queue, ^{
        // 追加任務 4
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"4---%@",[NSThread currentThread]);      // 打印當前線程
    });
}

輸出結果：
2019-08-08 14:59:02.540868+0800 YSC-GCD-demo[17648:4262933] 1---<NSThread: 0x600001ca4c40>{number = 3, name = (null)}
2019-08-08 14:59:02.540868+0800 YSC-GCD-demo[17648:4262932] 2---<NSThread: 0x600001c84a00>{number = 4, name = (null)}
2019-08-08 14:59:04.542346+0800 YSC-GCD-demo[17648:4262933] barrier---<NSThread: 0x600001ca4c40>{number = 3, name = (null)}
2019-08-08 14:59:06.542772+0800 YSC-GCD-demo[17648:4262932] 4---<NSThread: 0x600001c84a00>{number = 4, name = (null)}
2019-08-08 14:59:06.542773+0800 YSC-GCD-demo[17648:4262933] 3---<NSThread: 0x600001ca4c40>{number = 3, name = (null)}

在 dispatch_barrier_async 執行結果中可以看出：

  • 在執行完柵欄前面的操作之後，才執行柵欄操作，最後再執行柵欄後邊的操作。

6.2 GCD 延時執行方法：dispatch_after

我們經常會遇到這樣的需求：在指定時間（例如 3 秒）之後執行某個任務。可以用 GCD 的dispatch_after 方法來實現。
需要注意的是：dispatch_after 方法並不是在指定時間之後纔開始執行處理，而是在指定時間之後將任務追加到主隊列中。嚴格來說，這個時間並不是絕對準確的，但想要大致延遲執行任務，dispatch_after 方法是很有效的。

/**
 * 延時執行方法 dispatch_after
 */
- (void)after {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當前線程
    NSLog(@"asyncMain---begin");
    
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        // 2.0 秒後異步追加任務代碼到主隊列，並開始執行
        NSLog(@"after---%@",[NSThread currentThread]);  // 打印當前線程
    });
}

輸出結果：
2019-08-08 15:01:33.569710+0800 YSC-GCD-demo[17702:4272430] currentThread---<NSThread: 0x600001ead340>{number = 1, name = main}
2019-08-08 15:01:33.569838+0800 YSC-GCD-demo[17702:4272430] asyncMain---begin
2019-08-08 15:01:35.570146+0800 YSC-GCD-demo[17702:4272430] after---<NSThread: 0x600001ead340>{number = 1, name = main}

可以看出：在打印 asyncMain---begin 之後大約 2.0 秒的時間，打印了 after---<NSThread: 0x600001ead340>{number = 1, name = main}

6.3 GCD 一次性代碼（只執行一次）：dispatch_once

  • 我們在創建單例、或者有整個程序運行過程中只執行一次的代碼時，我們就用到了 GCD 的 dispatch_once 方法。使用 dispatch_once 方法能保證某段代碼在程序運行過程中只被執行 1 次，並且即使在多線程的環境下，dispatch_once 也可以保證線程安全。
/**
 * 一次性代碼（只執行一次）dispatch_once
 */
- (void)once {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        // 只執行 1 次的代碼（這裏面默認是線程安全的）
    });
}

6.4 GCD 快速迭代方法：dispatch_apply

  • 通常我們會用 for 循環遍歷，但是 GCD 給我們提供了快速迭代的方法 dispatch_apply。dispatch_apply 按照指定的次數將指定的任務追加到指定的隊列中，並等待全部隊列執行結束。

如果是在串行隊列中使用 dispatch_apply，那麼就和 for 循環一樣，按順序同步執行。但是這樣就體現不出快速迭代的意義了。

我們可以利用併發隊列進行異步執行。比如說遍歷 0~5 這 6 個數字，for 循環的做法是每次取出一個元素，逐個遍歷。dispatch_apply 可以 在多個線程中同時（異步）遍歷多個數字。

還有一點，無論是在串行隊列，還是併發隊列中，dispatch_apply 都會等待全部任務執行完畢，這點就像是同步操作，也像是隊列組中的 dispatch_group_wait方法。

/**
 * 快速迭代方法 dispatch_apply
 */
- (void)apply {
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    NSLog(@"apply---begin");
    dispatch_apply(6, queue, ^(size_t index) {
        NSLog(@"%zd---%@",index, [NSThread currentThread]);
    });
    NSLog(@"apply---end");
}

輸出結果：
2019-08-08 15:05:04.715266+0800 YSC-GCD-demo[17771:4285619] apply---begin
2019-08-08 15:05:04.715492+0800 YSC-GCD-demo[17771:4285619] 0---<NSThread: 0x600003bd1380>{number = 1, name = main}
2019-08-08 15:05:04.715516+0800 YSC-GCD-demo[17771:4285722] 1---<NSThread: 0x600003b82340>{number = 3, name = (null)}
2019-08-08 15:05:04.715526+0800 YSC-GCD-demo[17771:4285720] 3---<NSThread: 0x600003ba4cc0>{number = 5, name = (null)}
2019-08-08 15:05:04.715564+0800 YSC-GCD-demo[17771:4285721] 2---<NSThread: 0x600003bb9a80>{number = 7, name = (null)}
2019-08-08 15:05:04.715555+0800 YSC-GCD-demo[17771:4285719] 4---<NSThread: 0x600003b98100>{number = 6, name = (null)}
2019-08-08 15:05:04.715578+0800 YSC-GCD-demo[17771:4285728] 5---<NSThread: 0x600003beb400>{number = 4, name = (null)}
2019-08-08 15:05:04.715677+0800 YSC-GCD-demo[17771:4285619] apply---end

因爲是在併發隊列中異步執行任務，所以各個任務的執行時間長短不定，最後結束順序也不定。但是 apply---end 一定在最後執行。這是因爲 dispatch_apply 方法會等待全部任務執行完畢。

6.5 GCD 隊列組：dispatch_group

有時候我們會有這樣的需求：分別異步執行2個耗時任務，然後當2個耗時任務都執行完畢後再回到主線程執行任務。這時候我們可以用到 GCD 的隊列組。

  • 調用隊列組的 dispatch_group_async 先把任務放到隊列中，然後將隊列放入隊列組中。或者使用隊列組的 dispatch_group_enter、dispatch_group_leave 組合來實現 dispatch_group_async。
  • 調用隊列組的 dispatch_group_notify 回到指定線程執行任務。或者使用 dispatch_group_wait 回到當前線程繼續向下執行（會阻塞當前線程）。

6.5.1 dispatch_group_notify

  • 監聽 group 中任務的完成狀態，當所有的任務都執行完成後，追加任務到 group 中，並執行任務。
/**
 * 隊列組 dispatch_group_notify
 */
- (void)groupNotify {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當前線程
    NSLog(@"group---begin");
    
    dispatch_group_t group =  dispatch_group_create();
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任務 1
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任務 2
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的異步任務 1、任務 2 都執行完畢後，回到主線程執行下邊任務
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印當前線程

        NSLog(@"group---end");
    });
}

輸出結果：
2019-08-08 15:07:21.601734+0800 YSC-GCD-demo[17813:4293874] currentThread---<NSThread: 0x600003aad380>{number = 1, name = main}
2019-08-08 15:07:21.601871+0800 YSC-GCD-demo[17813:4293874] group---begin
2019-08-08 15:07:23.604854+0800 YSC-GCD-demo[17813:4294048] 2---<NSThread: 0x600003add100>{number = 4, name = (null)}
2019-08-08 15:07:23.604852+0800 YSC-GCD-demo[17813:4294053] 1---<NSThread: 0x600003ace4c0>{number = 3, name = (null)}
2019-08-08 15:07:25.606067+0800 YSC-GCD-demo[17813:4293874] 3---<NSThread: 0x600003aad380>{number = 1, name = main}
2019-08-08 15:07:25.606255+0800 YSC-GCD-demo[17813:4293874] group---end

從 dispatch_group_notify 相關代碼運行輸出結果可以看出：
當所有任務都執行完成之後，才執行 dispatch_group_notify 相關 block 中的任務。

6.5.2 dispatch_group_wait

  • 暫停當前線程（阻塞當前線程），等待指定的 group 中的任務執行完成後，纔會往下繼續執行。
/**
 * 隊列組 dispatch_group_wait
 */
- (void)groupWait {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當前線程
    NSLog(@"group---begin");
    
    dispatch_group_t group =  dispatch_group_create();
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任務 1
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任務 2
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    // 等待上面的任務全部完成後，會往下繼續執行（會阻塞當前線程）
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    
    NSLog(@"group---end");
    
}

輸出結果：
2019-08-08 15:09:12.441729+0800 YSC-GCD-demo[17844:4299926] currentThread---<NSThread: 0x6000013e2940>{number = 1, name = main}
2019-08-08 15:09:12.441870+0800 YSC-GCD-demo[17844:4299926] group---begin
2019-08-08 15:09:14.445790+0800 YSC-GCD-demo[17844:4300046] 2---<NSThread: 0x600001389780>{number = 4, name = (null)}
2019-08-08 15:09:14.445760+0800 YSC-GCD-demo[17844:4300043] 1---<NSThread: 0x600001381880>{number = 3, name = (null)}
2019-08-08 15:09:14.446039+0800 YSC-GCD-demo[17844:4299926] group---end

從 dispatch_group_wait 相關代碼運行輸出結果可以看出：
當所有任務執行完成之後，才執行 dispatch_group_wait 之後的操作。但是，使用dispatch_group_wait 會阻塞當前線程。

6.5.3 dispatch_group_enter、dispatch_group_leave

  • dispatch_group_enter 標誌着一個任務追加到 group，執行一次，相當於 group 中未執行完畢任務數 +1
  • dispatch_group_leave 標誌着一個任務離開了 group，執行一次，相當於 group 中未執行完畢任務數 -1。
  • 當 group 中未執行完畢任務數爲0的時候，纔會使 dispatch_group_wait 解除阻塞，以及執行追加到 dispatch_group_notify 中的任務。
/**
 * 隊列組 dispatch_group_enter、dispatch_group_leave
 */
- (void)groupEnterAndLeave {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當前線程
    NSLog(@"group---begin");
    
    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        // 追加任務 1
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當前線程

        dispatch_group_leave(group);
    });
    
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        // 追加任務 2
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印當前線程
        
        dispatch_group_leave(group);
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的異步操作都執行完畢後，回到主線程.
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印當前線程
    
        NSLog(@"group---end");
    });
}

輸出結果：
2019-08-08 15:13:17.983283+0800 YSC-GCD-demo[17924:4314716] currentThread---<NSThread: 0x600001ee5380>{number = 1, name = main}
2019-08-08 15:13:17.983429+0800 YSC-GCD-demo[17924:4314716] group---begin
2019-08-08 15:13:19.988898+0800 YSC-GCD-demo[17924:4314816] 2---<NSThread: 0x600001e9ca00>{number = 3, name = (null)}
2019-08-08 15:13:19.988888+0800 YSC-GCD-demo[17924:4314808] 1---<NSThread: 0x600001e94100>{number = 4, name = (null)}
2019-08-08 15:13:21.990450+0800 YSC-GCD-demo[17924:4314716] 3---<NSThread: 0x600001ee5380>{number = 1, name = main}
2019-08-08 15:13:21.990711+0800 YSC-GCD-demo[17924:4314716] group---end

從 dispatch_group_enter、dispatch_group_leave 相關代碼運行結果中可以看出：當所有任務執行完成之後，才執行 dispatch_group_notify 中的任務。這裏的dispatch_group_enter、dispatch_group_leave 組合，其實等同於dispatch_group_async。

6.6 GCD 信號量：dispatch_semaphore

GCD 中的信號量是指 Dispatch Semaphore，是持有計數的信號。類似於過高速路收費站的欄杆。可以通過時，打開欄杆，不可以通過時，關閉欄杆。在 Dispatch Semaphore 中，使用計數來完成這個功能，計數小於 0 時等待，不可通過。計數爲 0 或大於 0 時，計數減 1 且不等待，可通過。
Dispatch Semaphore 提供了三個方法：

  • dispatch_semaphore_create：創建一個 Semaphore 並初始化信號的總量
  • dispatch_semaphore_signal：發送一個信號，讓信號總量加 1
  • dispatch_semaphore_wait：可以使總信號量減 1，信號總量小於 0 時就會一直等待（阻塞所在線程），否則就可以正常執行。

注意：信號量的使用前提是：想清楚你需要處理哪個線程等待（阻塞），又要哪個線程繼續執行，然後使用信號量。

Dispatch Semaphore 在實際開發中主要用於：

  • 保持線程同步，將異步執行任務轉換爲同步執行任務
  • 保證線程安全，爲線程加鎖

6.6.1 Dispatch Semaphore 線程同步

我們在開發中，會遇到這樣的需求：異步執行耗時任務，並使用異步執行的結果進行一些額外的操作。換句話說，相當於，將將異步執行任務轉換爲同步執行任務。比如說：AFNetworking 中 AFURLSessionManager.m 裏面的 tasksForKeyPath: 方法。通過引入信號量的方式，等待異步執行任務結果，獲取到 tasks，然後再返回該 tasks。

- (NSArray *)tasksForKeyPath:(NSString *)keyPath {
    __block NSArray *tasks = nil;
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    [self.session getTasksWithCompletionHandler:^(NSArray *dataTasks, NSArray *uploadTasks, NSArray *downloadTasks) {
        if ([keyPath isEqualToString:NSStringFromSelector(@selector(dataTasks))]) {
            tasks = dataTasks;
        } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(uploadTasks))]) {
            tasks = uploadTasks;
        } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(downloadTasks))]) {
            tasks = downloadTasks;
        } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(tasks))]) {
            tasks = [@[dataTasks, uploadTasks, downloadTasks] valueForKeyPath:@"@unionOfArrays.self"];
        }

        dispatch_semaphore_signal(semaphore);
    }];

    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

    return tasks;
}

下面，我們來利用 Dispatch Semaphore 實現線程同步，將異步執行任務轉換爲同步執行任務。

/**
 * semaphore 線程同步
 */
- (void)semaphoreSync {
    
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當前線程
    NSLog(@"semaphore---begin");
    
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    
    __block int number = 0;
    dispatch_async(queue, ^{
        // 追加任務 1
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當前線程
        
        number = 100;
        
        dispatch_semaphore_signal(semaphore);
    });
    
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    NSLog(@"semaphore---end,number = %zd",number);
}

輸出結果：
2019-08-08 15:16:56.781543+0800 YSC-GCD-demo[17988:4325744] currentThread---<NSThread: 0x60000298d380>{number = 1, name = main}
2019-08-08 15:16:56.781698+0800 YSC-GCD-demo[17988:4325744] semaphore---begin
2019-08-08 15:16:58.785232+0800 YSC-GCD-demo[17988:4325867] 1---<NSThread: 0x6000029eba80>{number = 3, name = (null)}
2019-08-08 15:16:58.785432+0800 YSC-GCD-demo[17988:4325744] semaphore---end,number = 100

從 Dispatch Semaphore 實現線程同步的代碼可以看到：

  • semaphore---end 是在執行完 number = 100; 之後纔打印的。而且輸出結果 number 爲 100。這是因爲 異步執行 不會做任何等待，可以繼續執行任務。
    執行順如下：
    1. semaphore 初始創建時計數爲 0。
    2. 異步執行 將 任務 1 追加到隊列之後，不做等待，接着執行 dispatch_semaphore_wait 方法，semaphore 減 1，此時 semaphore == -1，當前線程進入等待狀態。
    3. 然後，異步任務 1 開始執行。任務 1 執行到 dispatch_semaphore_signal 之後，總信號量加 1，此時 semaphore == 0，正在被阻塞的線程（主線程）恢復繼續執行。
    4. 最後打印 semaphore---end,number = 100。

這樣就實現了線程同步，將異步執行任務轉換爲同步執行任務。

6.6.2 Dispatch Semaphore 線程安全和線程同步（爲線程加鎖）

線程安全：如果你的代碼所在的進程中有多個線程在同時運行，而這些線程可能會同時運行這段代碼。如果每次運行結果和單線程運行的結果是一樣的，而且其他的變量的值也和預期的是一樣的，就是線程安全的。

若每個線程中對全局變量、靜態變量只有讀操作，而無寫操作，一般來說，這個全局變量是線程安全的；若有多個線程同時執行寫操作（更改變量），一般都需要考慮線程同步，否則的話就可能影響線程安全。

線程同步：可理解爲線程 A 和 線程 B 一塊配合，A 執行到一定程度時要依靠線程 B 的某個結果，於是停下來，示意 B 運行；B 依言執行，再將結果給 A；A 再繼續操作。

舉個簡單例子就是：兩個人在一起聊天。兩個人不能同時說話，避免聽不清(操作衝突)。等一個人說完(一個線程結束操作)，另一個再說(另一個線程再開始操作)。

下面，我們模擬火車票售賣的方式，實現 NSThread 線程安全和解決線程同步問題。

場景：總共有 50 張火車票，有兩個售賣火車票的窗口，一個是北京火車票售賣窗口，另一個是上海火車票售賣窗口。兩個窗口同時售賣火車票，賣完爲止。

6.6.2.1 非線程安全（不使用 semaphore）

先來看看不考慮線程安全的代碼：

/**
 * 非線程安全：不使用 semaphore
 * 初始化火車票數量、賣票窗口（非線程安全）、並開始賣票
 */
- (void)initTicketStatusNotSave {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當前線程
    NSLog(@"semaphore---begin");
    
    self.ticketSurplusCount = 50;
    
    // queue1 代表北京火車票售賣窗口
    dispatch_queue_t queue1 = dispatch_queue_create("net.bujige.testQueue1", DISPATCH_QUEUE_SERIAL);
    // queue2 代表上海火車票售賣窗口
    dispatch_queue_t queue2 = dispatch_queue_create("net.bujige.testQueue2", DISPATCH_QUEUE_SERIAL);
    
    __weak typeof(self) weakSelf = self;
    dispatch_async(queue1, ^{
        [weakSelf saleTicketNotSafe];
    });
    
    dispatch_async(queue2, ^{
        [weakSelf saleTicketNotSafe];
    });
}

/**
 * 售賣火車票（非線程安全）
 */
- (void)saleTicketNotSafe {
    while (1) {
        
        if (self.ticketSurplusCount > 0) {  // 如果還有票，繼續售賣
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩餘票數：%d 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        } else { // 如果已賣完，關閉售票窗口
            NSLog(@"所有火車票均已售完");
            break;
        }
        
    }
}

輸出結果（部分）：
2019-08-08 15:21:39.772655+0800 YSC-GCD-demo[18071:4340555] currentThread---<NSThread: 0x6000015a2f40>{number = 1, name = main}
2019-08-08 15:21:39.772790+0800 YSC-GCD-demo[18071:4340555] semaphore---begin
2019-08-08 15:21:39.773101+0800 YSC-GCD-demo[18071:4340604] 剩餘票數：48 窗口：<NSThread: 0x6000015cc600>{number = 4, name = (null)}
2019-08-08 15:21:39.773115+0800 YSC-GCD-demo[18071:4340605] 剩餘票數：49 窗口：<NSThread: 0x6000015f8600>{number = 3, name = (null)}
2019-08-08 15:21:39.975041+0800 YSC-GCD-demo[18071:4340605] 剩餘票數：47 窗口：<NSThread: 0x6000015f8600>{number = 3, name = (null)}
2019-08-08 15:21:39.975037+0800 YSC-GCD-demo[18071:4340604] 剩餘票數：47 窗口：<NSThread: 0x6000015cc600>{number = 4, name = (null)}
2019-08-08 15:21:40.176567+0800 YSC-GCD-demo[18071:4340604] 剩餘票數：46 窗口：<NSThread: 0x6000015cc600>{number = 4, name = (null)}
...

可以看到在不考慮線程安全，不使用 semaphore 的情況下，得到票數是錯亂的，這樣顯然不符合我們的需求，所以我們需要考慮線程安全問題。

6.6.2.2 線程安全（使用 semaphore 加鎖）

考慮線程安全的代碼：

/**
 * 線程安全：使用 semaphore 加鎖
 * 初始化火車票數量、賣票窗口（線程安全）、並開始賣票
 */
- (void)initTicketStatusSave {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當前線程
    NSLog(@"semaphore---begin");
    
    semaphoreLock = dispatch_semaphore_create(1);
    
    self.ticketSurplusCount = 50;
    
    // queue1 代表北京火車票售賣窗口
    dispatch_queue_t queue1 = dispatch_queue_create("net.bujige.testQueue1", DISPATCH_QUEUE_SERIAL);
    // queue2 代表上海火車票售賣窗口
    dispatch_queue_t queue2 = dispatch_queue_create("net.bujige.testQueue2", DISPATCH_QUEUE_SERIAL);
    
    __weak typeof(self) weakSelf = self;
    dispatch_async(queue1, ^{
        [weakSelf saleTicketSafe];
    });
    
    dispatch_async(queue2, ^{
        [weakSelf saleTicketSafe];
    });
}

/**
 * 售賣火車票（線程安全）
 */
- (void)saleTicketSafe {
    while (1) {
        // 相當於加鎖
        dispatch_semaphore_wait(semaphoreLock, DISPATCH_TIME_FOREVER);
        
        if (self.ticketSurplusCount > 0) {  // 如果還有票，繼續售賣
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩餘票數：%d 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        } else { // 如果已賣完，關閉售票窗口
            NSLog(@"所有火車票均已售完");
            
            // 相當於解鎖
            dispatch_semaphore_signal(semaphoreLock);
            break;
        }
        
        // 相當於解鎖
        dispatch_semaphore_signal(semaphoreLock);
    }
}

輸出結果爲：
2019-08-08 15:23:58.819891+0800 YSC-GCD-demo[18116:4348091] currentThread---<NSThread: 0x600000681380>{number = 1, name = main}
2019-08-08 15:23:58.820041+0800 YSC-GCD-demo[18116:4348091] semaphore---begin
2019-08-08 15:23:58.820305+0800 YSC-GCD-demo[18116:4348159] 剩餘票數：49 窗口：<NSThread: 0x6000006ede80>{number = 3, name = (null)}
2019-08-08 15:23:59.022165+0800 YSC-GCD-demo[18116:4348157] 剩餘票數：48 窗口：<NSThread: 0x6000006e4b40>{number = 4, name = (null)}
2019-08-08 15:23:59.225299+0800 YSC-GCD-demo[18116:4348159] 剩餘票數：47 窗口：<NSThread: 0x6000006ede80>{number = 3, name = (null)}
...
2019-08-08 15:24:08.355977+0800 YSC-GCD-demo[18116:4348157] 剩餘票數：2 窗口：<NSThread: 0x6000006e4b40>{number = 4, name = (null)}
2019-08-08 15:24:08.559201+0800 YSC-GCD-demo[18116:4348159] 剩餘票數：1 窗口：<NSThread: 0x6000006ede80>{number = 3, name = (null)}
2019-08-08 15:24:08.759630+0800 YSC-GCD-demo[18116:4348157] 剩餘票數：0 窗口：<NSThread: 0x6000006e4b40>{number = 4, name = (null)}
2019-08-08 15:24:08.965100+0800 YSC-GCD-demo[18116:4348159] 所有火車票均已售完
2019-08-08 15:24:08.965440+0800 YSC-GCD-demo[18116:4348157] 所有火車票均已售完

可以看出，在考慮了線程安全的情況下，使用 dispatch_semaphore
機制之後，得到的票數是正確的，沒有出現混亂的情況。我們也就解決了多個線程同步的問題。

參考資料：

iOS 多線程詳盡總結系列文章：

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

App Store審覈失敗，失敗的22個原因。

1、Terms and conditions(法律與條款)　　作爲App Store的應用開發者，你必須接受如下條款：Program License Agreement(PLA)，Human Interface Guidelines(HI

theFeng- 2020-07-08 07:14:34

ios開發 － Xcode升級後的警告、錯誤的解決辦法

<span style="font-size:24px;">1， 錯誤信息： "_OBJC_CLASS_$ xxxxx ", referenced from: objc-class-ref in ViewContro

theFeng- 2020-07-08 07:14:34

X－code 6中使用iOS7 SDK的方法

從XCODE 5的目錄中: /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs 把iPhoneOS7.1.sdk

theFeng- 2020-07-08 07:14:33

[1]SwiftUI

Text Text(landmark.location) .font(.subheadline)//字體的大小 .foregroundColor(.secondary)//secondary一個比較常用的灰色字體 .p

花爷爷 2020-07-06 23:53:07

swift Playground

主要的結構： 如何在playground中添加新的playground Playground寫左邊顯示的md 裏面要添加liveView .swift就是要寫的liveView Resources裏面放圖片或者音頻之類的

花爷爷 2020-07-06 23:53:07

Swift ViewControllerTransitions

文章目錄自定義Modally轉場動畫準備兩個非交互動畫的動畫器創建動畫器遵循兩個協議完成動畫器在VC上設置dismiss交互動畫的動畫器創建動畫器添加交互動畫的flag完成交互動畫自定義Navigation轉場動畫準備完成兩個非交

花爷爷 2020-07-06 23:53:07

Todos App

地址 Todos 用Realm數據庫 用SWiftUI Todos的功能： 添加數據 更改數據 刪除數據 批量刪除數據 移動數據 Main.storyboard: 刪除原本的ViewController 創建一個Table Vie

花爷爷 2020-07-06 23:53:07

SwiftUI添加PageViewController

創建一個PageVC.swift,遵循協議UIViewControllerRepresentable UIViewControllerRepresentable要完成兩個必選方法 func makeUIViewControlle

花爷爷 2020-07-06 23:53:07

[3]SwiftUI

Transition 移動用Transition,變化用Animation .asymmetric可以將進入進出動畫分離各自設置 .combined豐富動畫內容 AnyTransition表面顯示多種動畫 HikeDetail(

花爷爷 2020-07-06 23:53:07

swift學習筆記 --- Closures

一.閉包創建語法        {（parameters） -> return type in          statements   }  例子 ：           let names = ["Chris","Alex","Ew

iOS-null 2020-07-06 01:18:49

UIGraphicsBeginImageContext UIGraphicsGetImageFromCurrentImageContext 壓縮，修改，截取圖片

//獲取圖片的縮略圖 + (UIImage *)thumbnailWithImageWithoutScale:(UIImage *)image size:(CGSize)asize{ UIImage *newimage;

疯狂的小虫 2020-07-04 17:16:41

iOS 自定意義cell左右滑動，添加自定意義button

方案一  左滑支持文字 先付上 iOS8自帶的 cell滑動  [objc] view plain copy   // 主要代碼   #pragma mark 在滑動手勢刪除某一行的時候，顯示出更多的按鈕 

Amydom 2020-07-03 15:39:17

iOS OS X EL Capitan安裝CocoaPods遇過的坑

1.移除現有Ruby默認源 $gem sources --remove https://rubygems.org/ 2.使用新的源 $gem sources -a https://ruby.taobao.org/ 3.驗

Amydom 2020-07-03 15:39:17

iOS 調取本地地圖以及三方地圖

地圖在我們 App 開發中已經算是一項比較基本的功能了,但是有些時候不需要我們去集成地圖,而是通過調取本地地圖來實現定位,我上網查了下,完成的能跑通的調用本地地圖的 demo 少之又少,於是就試着自己總結了一下 首先,我們需要導入兩個系統

Amydom 2020-07-03 15:39:17

iOS 錄像功能的簡單實現

話不多說,上 DEMO 這裏用的是 SVProressHUD, 由於 iOS10 的權限緣故,需要在 plist 裏添加字段,否則會崩潰,具體請看上一篇 // // ViewController.m // 錄製視頻 // // Cr

Amydom 2020-07-03 15:39:17