無標題文章

本文用來介紹 iOS 多線程中 GCD 的相關知識以及使用方法。這大概是史上最詳細、清晰的關于 GCD 的詳細講解+總結的文章了。通過本文，您將了解到：

1. GCD 簡介

2. GCD 任務和隊列

3. GCD 的使用步驟

4. GCD 的基本使用（6種不同組合區別）

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）。兩者的主要區別是：是否等待隊列的任務執行結束，以及是否具備開啟新線程的能力。

同步執行（sync）：

同步添加任務到指定的隊列中，在添加的任務執行結束之前，會一直等待，直到隊列里面的任務完成之后再繼續執行。

只能在當前線程中執行任務，不具備開啟新線程的能力。

異步執行（async）：

異步添加任務到指定的隊列中，它不會做任何等待，可以繼續執行任務。

可以在新的線程中執行任務，具備開啟新線程的能力。

舉個簡單例子：你要打電話給小明和小白。

同步執行就是，你打電話給小明的時候，不能同時打給小白，等到給小明打完了，才能打給小白（等待任務執行結束）。而且只能用當前的電話（不具備開啟新線程的能力）。

而異步執行就是，你打電話給小明的時候，不等和小明通話結束，還能直接給小白打電話，不用等著和小明通話結束再打（不用等待任務執行結束）。除了當前電話，你還可以使用其他所能使用的電話（具備開啟新線程的能力）。

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

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

隊列(Dispatch Queue).png

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

串行隊列（Serial Dispatch Queue）：

每次只有一個任務被執行。讓任務一個接著一個地執行。（只開啟一個線程，一個任務執行完畢后，再執行下一個任務）

并發隊列（Concurrent Dispatch Queue）：

可以讓多個任務并發（同時）執行。（可以開啟多個線程，并且同時執行任務）

注意：并發隊列的并發功能只有在異步（dispatch_async）函數下才有效

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

串行隊列.png

并發隊列.png

3. GCD 的使用步驟

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

創建一個隊列（串行隊列或并發隊列）

將任務追加到任務的等待隊列中，然后系統就會根據任務類型執行任務（同步執行或異步執行）

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

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

可以使用dispatch_queue_create來創建隊列，需要傳入兩個參數，第一個參數表示隊列的唯一標識符，用于 DEBUG，可為空，Dispatch Queue 的名稱推薦使用應用程序 ID 這種逆序全程域名；第二個參數用來識別是串行隊列還是并發隊列。DISPATCH_QUEUE_SERIAL表示串行隊列，DISPATCH_QUEUE_CONCURRENT表示并發隊列。

// 串行隊列的創建方法dispatch_queue_tqueue= dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);// 并發隊列的創建方法dispatch_queue_tqueue= dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);

對于串行隊列，GCD 提供了的一種特殊的串行隊列：主隊列（Main Dispatch Queue）。

所有放在主隊列中的任務，都會放到主線程中執行。

可使用dispatch_get_main_queue()獲得主隊列。

// 主隊列的獲取方法dispatch_queue_tqueue= dispatch_get_main_queue();

對于并發隊列，GCD 默認提供了全局并發隊列（Global Dispatch Queue）。

可以使用dispatch_get_global_queue來獲取。需要傳入兩個參數。第一個參數表示隊列優先級，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二個參數暫時沒用，用0即可。

// 全局并發隊列的獲取方法dispatch_queue_tqueue= dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);

3.2 任務的創建方法

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

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

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

同步執行 + 并發隊列

異步執行 + 并發隊列

同步執行 + 串行隊列

異步執行 + 串行隊列

實際上，剛才還說了兩種特殊隊列：全局并發隊列、主隊列。全局并發隊列可以作為普通并發隊列來使用。但是主隊列因為有點特殊，所以我們就又多了兩種組合方式。這樣就有六種不同的組合方式了。

同步執行 + 主隊列

異步執行 + 主隊列

那么這幾種不同組合方式各有什么區別呢，這里為了方便，先上結果，再來講解。你可以直接查看表格結果，然后跳過4. GCD的基本使用。

區別并發隊列串行隊列主隊列

同步(sync)沒有開啟新線程，串行執行任務沒有開啟新線程，串行執行任務主線程調用：死鎖卡住不執行

其他線程調用：沒有開啟新線程，串行執行任務

異步(async)有開啟新線程，并發執行任務有開啟新線程(1條)，串行執行任務沒有開啟新線程，串行執行任務

下邊我們來分別講講這幾種不同的組合方式的使用方法。

4. GCD 的基本使用

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

4.1 同步執行 + 并發隊列

在當前線程中執行任務，不會開啟新線程，執行完一個任務，再執行下一個任務。

/**

* 同步執行 + 并發隊列

* 特點：在當前線程中執行任務，不會開啟新線程，執行完一個任務，再執行下一個任務。

*/- (void)syncConcurrent {NSLog(@"currentThread---%@",[NSThreadcurrentThread]);// 打印當前線程NSLog(@"syncConcurrent---begin");dispatch_queue_tqueue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);dispatch_sync(queue, ^{// 追加任務1for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"1---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });dispatch_sync(queue, ^{// 追加任務2for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"2---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });dispatch_sync(queue, ^{// 追加任務3for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"3---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });NSLog(@"syncConcurrent---end");}

輸出結果：

2018-02-23 20:34:55.095932+0800 YSC-GCD-demo[19892:4996930] currentThread---{number = 1, name = main}

2018-02-23 20:34:55.096086+0800 YSC-GCD-demo[19892:4996930] syncConcurrent---begin

2018-02-23 20:34:57.097589+0800 YSC-GCD-demo[19892:4996930] 1---{number = 1, name = main}

2018-02-23 20:34:59.099100+0800 YSC-GCD-demo[19892:4996930] 1---{number = 1, name = main}

2018-02-23 20:35:01.099843+0800 YSC-GCD-demo[19892:4996930] 2---{number = 1, name = main}

2018-02-23 20:35:03.101171+0800 YSC-GCD-demo[19892:4996930] 2---{number = 1, name = main}

2018-02-23 20:35:05.101750+0800 YSC-GCD-demo[19892:4996930] 3---{number = 1, name = main}

2018-02-23 20:35:07.102414+0800 YSC-GCD-demo[19892:4996930] 3---{number = 1, name = main}

2018-02-23 20:35:07.102575+0800 YSC-GCD-demo[19892:4996930] syncConcurrent---end

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

所有任務都是在當前線程（主線程）中執行的，沒有開啟新的線程（同步執行不具備開啟新線程的能力）。

所有任務都在打印的syncConcurrent---begin和syncConcurrent---end之間執行的（同步任務需要等待隊列的任務執行結束）。

任務按順序執行的。按順序執行的原因：雖然并發隊列可以開啟多個線程，并且同時執行多個任務。但是因為本身不能創建新線程，只有當前線程這一個線程（同步任務不具備開啟新線程的能力），所以也就不存在并發。而且當前線程只有等待當前隊列中正在執行的任務執行完畢之后，才能繼續接著執行下面的操作（同步任務需要等待隊列的任務執行結束）。所以任務只能一個接一個按順序執行，不能同時被執行。

4.2 異步執行 + 并發隊列

可以開啟多個線程，任務交替（同時）執行。

/**

* 異步執行 + 并發隊列

* 特點：可以開啟多個線程，任務交替（同時）執行。

*/- (void)asyncConcurrent {NSLog(@"currentThread---%@",[NSThreadcurrentThread]);// 打印當前線程NSLog(@"asyncConcurrent---begin");dispatch_queue_tqueue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);dispatch_async(queue, ^{// 追加任務1for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"1---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });dispatch_async(queue, ^{// 追加任務2for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"2---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });dispatch_async(queue, ^{// 追加任務3for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"3---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });NSLog(@"asyncConcurrent---end");}

輸出結果：

2018-02-23 20:36:41.769269+0800 YSC-GCD-demo[19929:5005237] currentThread---{number = 1, name = main}

2018-02-23 20:36:41.769496+0800 YSC-GCD-demo[19929:5005237] asyncConcurrent---begin

2018-02-23 20:36:41.769725+0800 YSC-GCD-demo[19929:5005237] asyncConcurrent---end

2018-02-23 20:36:43.774442+0800 YSC-GCD-demo[19929:5005566] 2---{number = 5, name = (null)}

2018-02-23 20:36:43.774440+0800 YSC-GCD-demo[19929:5005567] 3---{number = 4, name = (null)}

2018-02-23 20:36:43.774440+0800 YSC-GCD-demo[19929:5005565] 1---{number = 3, name = (null)}

2018-02-23 20:36:45.779286+0800 YSC-GCD-demo[19929:5005567] 3---{number = 4, name = (null)}

2018-02-23 20:36:45.779302+0800 YSC-GCD-demo[19929:5005565] 1---{number = 3, name = (null)}

2018-02-23 20:36:45.779286+0800 YSC-GCD-demo[19929:5005566] 2---{number = 5, name = (null)}

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

除了當前線程（主線程），系統又開啟了3個線程，并且任務是交替/同時執行的。（異步執行具備開啟新線程的能力。且并發隊列可開啟多個線程，同時執行多個任務）。

所有任務是在打印的syncConcurrent---begin和syncConcurrent---end之后才執行的。說明當前線程沒有等待，而是直接開啟了新線程，在新線程中執行任務（異步執行不做等待，可以繼續執行任務）。

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

4.3 同步執行 + 串行隊列

不會開啟新線程，在當前線程執行任務。任務是串行的，執行完一個任務，再執行下一個任務。

/**

* 同步執行 + 串行隊列

* 特點：不會開啟新線程，在當前線程執行任務。任務是串行的，執行完一個任務，再執行下一個任務。

*/- (void)syncSerial {NSLog(@"currentThread---%@",[NSThreadcurrentThread]);// 打印當前線程NSLog(@"syncSerial---begin");dispatch_queue_tqueue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);dispatch_sync(queue, ^{// 追加任務1for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"1---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });dispatch_sync(queue, ^{// 追加任務2for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"2---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });dispatch_sync(queue, ^{// 追加任務3for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"3---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });NSLog(@"syncSerial---end");}

輸出結果為：

2018-02-23 20:39:37.876811+0800 YSC-GCD-demo[19975:5017162] currentThread---{number = 1, name = main}

2018-02-23 20:39:37.876998+0800 YSC-GCD-demo[19975:5017162] syncSerial---begin

2018-02-23 20:39:39.878316+0800 YSC-GCD-demo[19975:5017162] 1---{number = 1, name = main}

2018-02-23 20:39:41.879829+0800 YSC-GCD-demo[19975:5017162] 1---{number = 1, name = main}

2018-02-23 20:39:43.880660+0800 YSC-GCD-demo[19975:5017162] 2---{number = 1, name = main}

2018-02-23 20:39:45.881265+0800 YSC-GCD-demo[19975:5017162] 2---{number = 1, name = main}

2018-02-23 20:39:47.882257+0800 YSC-GCD-demo[19975:5017162] 3---{number = 1, name = main}

2018-02-23 20:39:49.883008+0800 YSC-GCD-demo[19975:5017162] 3---{number = 1, name = main}

2018-02-23 20:39:49.883253+0800 YSC-GCD-demo[19975:5017162] syncSerial---end

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

所有任務都是在當前線程（主線程）中執行的，并沒有開啟新的線程（同步執行不具備開啟新線程的能力）。

所有任務都在打印的syncConcurrent---begin和syncConcurrent---end之間執行（同步任務需要等待隊列的任務執行結束）。

任務是按順序執行的（串行隊列每次只有一個任務被執行，任務一個接一個按順序執行）。

4.4 異步執行 + 串行隊列

會開啟新線程，但是因為任務是串行的，執行完一個任務，再執行下一個任務

/**

* 異步執行 + 串行隊列

* 特點：會開啟新線程，但是因為任務是串行的，執行完一個任務，再執行下一個任務。

*/- (void)asyncSerial {NSLog(@"currentThread---%@",[NSThreadcurrentThread]);// 打印當前線程NSLog(@"asyncSerial---begin");dispatch_queue_tqueue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);dispatch_async(queue, ^{// 追加任務1for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"1---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });dispatch_async(queue, ^{// 追加任務2for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"2---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });dispatch_async(queue, ^{// 追加任務3for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"3---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });NSLog(@"asyncSerial---end");}

輸出結果為：

2018-02-23 20:41:17.029999+0800 YSC-GCD-demo[20008:5024757] currentThread---{number = 1, name = main}

2018-02-23 20:41:17.030212+0800 YSC-GCD-demo[20008:5024757] asyncSerial---begin

2018-02-23 20:41:17.030364+0800 YSC-GCD-demo[20008:5024757] asyncSerial---end

2018-02-23 20:41:19.035379+0800 YSC-GCD-demo[20008:5024950] 1---{number = 3, name = (null)}

2018-02-23 20:41:21.037140+0800 YSC-GCD-demo[20008:5024950] 1---{number = 3, name = (null)}

2018-02-23 20:41:23.042220+0800 YSC-GCD-demo[20008:5024950] 2---{number = 3, name = (null)}

2018-02-23 20:41:25.042971+0800 YSC-GCD-demo[20008:5024950] 2---{number = 3, name = (null)}

2018-02-23 20:41:27.047690+0800 YSC-GCD-demo[20008:5024950] 3---{number = 3, name = (null)}

2018-02-23 20:41:29.052327+0800 YSC-GCD-demo[20008:5024950] 3---{number = 3, name = (null)}

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

開啟了一條新線程（異步執行具備開啟新線程的能力，串行隊列只開啟一個線程）。

所有任務是在打印的syncConcurrent---begin和syncConcurrent---end之后才開始執行的（異步執行不會做任何等待，可以繼續執行任務）。

任務是按順序執行的（串行隊列每次只有一個任務被執行，任務一個接一個按順序執行）。

下邊講講剛才我們提到過的特殊隊列：主隊列。

主隊列：GCD自帶的一種特殊的串行隊列

所有放在主隊列中的任務，都會放到主線程中執行

可使用dispatch_get_main_queue()獲得主隊列

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

4.5 同步執行 + 主隊列

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

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

互相等待卡住不可行

/**

* 同步執行 + 主隊列

* 特點(主線程調用)：互等卡主不執行。

* 特點(其他線程調用)：不會開啟新線程，執行完一個任務，再執行下一個任務。

*/- (void)syncMain {NSLog(@"currentThread---%@",[NSThreadcurrentThread]);// 打印當前線程NSLog(@"syncMain---begin");dispatch_queue_tqueue = dispatch_get_main_queue();dispatch_sync(queue, ^{// 追加任務1for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"1---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });dispatch_sync(queue, ^{// 追加任務2for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"2---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });dispatch_sync(queue, ^{// 追加任務3for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"3---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });NSLog(@"syncMain---end");}

輸出結果

2018-02-23 20:42:36.842892+0800 YSC-GCD-demo[20041:5030982] currentThread---{number = 1, name = main}

2018-02-23 20:42:36.843050+0800 YSC-GCD-demo[20041:5030982] 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 任務[NSThreaddetachNewThreadSelector:@selector(syncMain) toTarget:selfwithObject:nil];

輸出結果：

2018-02-23 20:44:19.377321+0800 YSC-GCD-demo[20083:5040347] currentThread---{number = 3, name = (null)}

2018-02-23 20:44:19.377494+0800 YSC-GCD-demo[20083:5040347] syncMain---begin

2018-02-23 20:44:21.384716+0800 YSC-GCD-demo[20083:5040132] 1---{number = 1, name = main}

2018-02-23 20:44:23.386091+0800 YSC-GCD-demo[20083:5040132] 1---{number = 1, name = main}

2018-02-23 20:44:25.387687+0800 YSC-GCD-demo[20083:5040132] 2---{number = 1, name = main}

2018-02-23 20:44:27.388648+0800 YSC-GCD-demo[20083:5040132] 2---{number = 1, name = main}

2018-02-23 20:44:29.390459+0800 YSC-GCD-demo[20083:5040132] 3---{number = 1, name = main}

2018-02-23 20:44:31.391965+0800 YSC-GCD-demo[20083:5040132] 3---{number = 1, name = main}

2018-02-23 20:44:31.392513+0800 YSC-GCD-demo[20083:5040347] syncMain---end

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

所有任務都是在主線程（非當前線程）中執行的，沒有開啟新的線程（所有放在主隊列中的任務，都會放到主線程中執行）。

所有任務都在打印的syncConcurrent---begin和syncConcurrent---end之間執行（同步任務需要等待隊列的任務執行結束）。

任務是按順序執行的（主隊列是串行隊列，每次只有一個任務被執行，任務一個接一個按順序執行）。

為什么現在就不會卡住了呢？

因為syncMain 任務放到了其他線程里，而任務1、任務2、任務3都在追加到主隊列中，這三個任務都會在主線程中執行。syncMain 任務在其他線程中執行到追加任務1到主隊列中，因為主隊列現在沒有正在執行的任務，所以，會直接執行主隊列的任務1，等任務1執行完畢，再接著執行任務2、任務3。所以這里不會卡住線程。

4.6 異步執行 + 主隊列

只在主線程中執行任務，執行完一個任務，再執行下一個任務。

/**

* 異步執行 + 主隊列

* 特點：只在主線程中執行任務，執行完一個任務，再執行下一個任務

*/- (void)asyncMain {NSLog(@"currentThread---%@",[NSThreadcurrentThread]);// 打印當前線程NSLog(@"asyncMain---begin");dispatch_queue_tqueue = dispatch_get_main_queue();dispatch_async(queue, ^{// 追加任務1for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"1---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });dispatch_async(queue, ^{// 追加任務2for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"2---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });dispatch_async(queue, ^{// 追加任務3for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"3---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });NSLog(@"asyncMain---end");}

輸出結果：

2018-02-23 20:45:49.981505+0800 YSC-GCD-demo[20111:5046708] currentThread---{number = 1, name = main}

2018-02-23 20:45:49.981935+0800 YSC-GCD-demo[20111:5046708] asyncMain---begin

2018-02-23 20:45:49.982352+0800 YSC-GCD-demo[20111:5046708] asyncMain---end

2018-02-23 20:45:51.991096+0800 YSC-GCD-demo[20111:5046708] 1---{number = 1, name = main}

2018-02-23 20:45:53.991959+0800 YSC-GCD-demo[20111:5046708] 1---{number = 1, name = main}

2018-02-23 20:45:55.992937+0800 YSC-GCD-demo[20111:5046708] 2---{number = 1, name = main}

2018-02-23 20:45:57.993649+0800 YSC-GCD-demo[20111:5046708] 2---{number = 1, name = main}

2018-02-23 20:45:59.994928+0800 YSC-GCD-demo[20111:5046708] 3---{number = 1, name = main}

2018-02-23 20:46:01.995589+0800 YSC-GCD-demo[20111:5046708] 3---{number = 1, name = main}

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

所有任務都是在當前線程（主線程）中執行的，并沒有開啟新的線程（雖然異步執行具備開啟線程的能力，但因為是主隊列，所以所有任務都在主線程中）。

所有任務是在打印的syncConcurrent---begin和syncConcurrent---end之后才開始執行的（異步執行不會做任何等待，可以繼續執行任務）。

任務是按順序執行的（因為主隊列是串行隊列，每次只有一個任務被執行，任務一個接一個按順序執行）。

弄懂了難理解、繞來繞去的隊列+任務之后，我們來學習一個簡單的東西：5. GCD 線程間的通信。

5. GCD 線程間的通信

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

/**

* 線程間通信

*/- (void)communication {// 獲取全局并發隊列dispatch_queue_tqueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);// 獲取主隊列dispatch_queue_tmainQueue = dispatch_get_main_queue();dispatch_async(queue, ^{// 異步追加任務for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"1---%@",[NSThreadcurrentThread]);// 打印當前線程}// 回到主線程dispatch_async(mainQueue, ^{// 追加在主線程中執行的任務[NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"2---%@",[NSThreadcurrentThread]);// 打印當前線程});? ? });}

輸出結果：

2018-02-23 20:47:03.462394+0800 YSC-GCD-demo[20154:5053282] 1---{number = 3, name = (null)}

2018-02-23 20:47:05.465912+0800 YSC-GCD-demo[20154:5053282] 1---{number = 3, name = (null)}

2018-02-23 20:47:07.466657+0800 YSC-GCD-demo[20154:5052953] 2---{number = 1, name = main}

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

6. GCD 的其他方法

6.1 GCD 柵欄方法：dispatch_barrier_async

我們有時需要異步執行兩組操作，而且第一組操作執行完之后，才能開始執行第二組操作。這樣我們就需要一個相當于柵欄一樣的一個方法將兩組異步執行的操作組給分割起來，當然這里的操作組里可以包含一個或多個任務。這就需要用到dispatch_barrier_async方法在兩個操作組間形成柵欄。

dispatch_barrier_async函數會等待前邊追加到并發隊列中的任務全部執行完畢之后，再將指定的任務追加到該異步隊列中。然后在dispatch_barrier_async函數追加的任務執行完畢之后，異步隊列才恢復為一般動作，接著追加任務到該異步隊列并開始執行。具體如下圖所示：

dispatch_barrier_async.png

/**

* 柵欄方法 dispatch_barrier_async

*/- (void)barrier {dispatch_queue_tqueue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);dispatch_async(queue, ^{// 追加任務1for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"1---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });dispatch_async(queue, ^{// 追加任務2for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"2---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });? ? ? ? dispatch_barrier_async(queue, ^{// 追加任務 barrierfor(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"barrier---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });dispatch_async(queue, ^{// 追加任務3for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"3---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });dispatch_async(queue, ^{// 追加任務4for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"4---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });}

輸出結果：

2018-02-23 20:48:18.297745+0800 YSC-GCD-demo[20188:5059274] 1---{number = 4, name = (null)}

2018-02-23 20:48:18.297745+0800 YSC-GCD-demo[20188:5059273] 2---{number = 3, name = (null)}

2018-02-23 20:48:20.301139+0800 YSC-GCD-demo[20188:5059274] 1---{number = 4, name = (null)}

2018-02-23 20:48:20.301139+0800 YSC-GCD-demo[20188:5059273] 2---{number = 3, name = (null)}

2018-02-23 20:48:22.306290+0800 YSC-GCD-demo[20188:5059274] barrier---{number = 4, name = (null)}

2018-02-23 20:48:24.311655+0800 YSC-GCD-demo[20188:5059274] barrier---{number = 4, name = (null)}

2018-02-23 20:48:26.316943+0800 YSC-GCD-demo[20188:5059273] 4---{number = 3, name = (null)}

2018-02-23 20:48:26.316956+0800 YSC-GCD-demo[20188:5059274] 3---{number = 4, name = (null)}

2018-02-23 20:48:28.320660+0800 YSC-GCD-demo[20188:5059273] 4---{number = 3, name = (null)}

2018-02-23 20:48:28.320649+0800 YSC-GCD-demo[20188:5059274] 3---{number = 4, name = (null)}

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

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

6.2 GCD 延時執行方法：dispatch_after

我們經常會遇到這樣的需求：在指定時間（例如3秒）之后執行某個任務。可以用 GCD 的dispatch_after函數來實現。

需要注意的是：dispatch_after函數并不是在指定時間之后才開始執行處理，而是在指定時間之后將任務追加到主隊列中。嚴格來說，這個時間并不是絕對準確的，但想要大致延遲執行任務，dispatch_after函數是很有效的。

/**

* 延時執行方法 dispatch_after

*/- (void)after {NSLog(@"currentThread---%@",[NSThreadcurrentThread]);// 打印當前線程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---%@",[NSThreadcurrentThread]);// 打印當前線程});}

輸出結果：

2018-02-23 20:53:08.713784+0800 YSC-GCD-demo[20282:5080295] currentThread---{number = 1, name = main}

2018-02-23 20:53:08.713962+0800 YSC-GCD-demo[20282:5080295] asyncMain---begin

2018-02-23 20:53:10.714283+0800 YSC-GCD-demo[20282:5080295] after---{number = 1, name = main}

可以看出：在打印asyncMain---begin之后大約 2.0 秒的時間，打印了after---{number = 1, name = main}

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

我們在創建單例、或者有整個程序運行過程中只執行一次的代碼時，我們就用到了 GCD 的dispatch_once函數。使用

dispatch_once函數能保證某段代碼在程序運行過程中只被執行1次，并且即使在多線程的環境下，dispatch_once也可以保證線程安全。

/**

* 一次性代碼（只執行一次）dispatch_once

*/- (void)once {staticdispatch_once_tonceToken;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_tqueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);NSLog(@"apply---begin");? ? dispatch_apply(6, queue, ^(size_t index) {NSLog(@"%zd---%@",index, [NSThreadcurrentThread]);? ? });NSLog(@"apply---end");}

輸出結果：

2018-02-23 22:03:18.475499+0800 YSC-GCD-demo[20470:5176805] apply---begin

2018-02-23 22:03:18.476672+0800 YSC-GCD-demo[20470:5177035] 1---{number = 3, name = (null)}

2018-02-23 22:03:18.476693+0800 YSC-GCD-demo[20470:5176805] 0---{number = 1, name = main}

2018-02-23 22:03:18.476704+0800 YSC-GCD-demo[20470:5177037] 2---{number = 4, name = (null)}

2018-02-23 22:03:18.476735+0800 YSC-GCD-demo[20470:5177036] 3---{number = 5, name = (null)}

2018-02-23 22:03:18.476867+0800 YSC-GCD-demo[20470:5177035] 4---{number = 3, name = (null)}

2018-02-23 22:03:18.476867+0800 YSC-GCD-demo[20470:5176805] 5---{number = 1, name = main}

2018-02-23 22:03:18.477038+0800 YSC-GCD-demo[20470:5176805] 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---%@",[NSThreadcurrentThread]);// 打印當前線程NSLog(@"group---begin");? ? ? ? dispatch_group_t group =? dispatch_group_create();? ? ? ? dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0), ^{// 追加任務1for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"1---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });? ? ? ? dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0), ^{// 追加任務2for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"2---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });? ? ? ? dispatch_group_notify(group, dispatch_get_main_queue(), ^{// 等前面的異步任務1、任務2都執行完畢后，回到主線程執行下邊任務for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"3---%@",[NSThreadcurrentThread]);// 打印當前線程}NSLog(@"group---end");? ? });}

輸出結果：

2018-02-23 22:05:03.790035+0800 YSC-GCD-demo[20494:5183349] currentThread---{number = 1, name = main}

2018-02-23 22:05:03.790237+0800 YSC-GCD-demo[20494:5183349] group---begin

2018-02-23 22:05:05.792721+0800 YSC-GCD-demo[20494:5183654] 1---{number = 4, name = (null)}

2018-02-23 22:05:05.792725+0800 YSC-GCD-demo[20494:5183656] 2---{number = 3, name = (null)}

2018-02-23 22:05:07.797408+0800 YSC-GCD-demo[20494:5183656] 2---{number = 3, name = (null)}

2018-02-23 22:05:07.797408+0800 YSC-GCD-demo[20494:5183654] 1---{number = 4, name = (null)}

2018-02-23 22:05:09.798717+0800 YSC-GCD-demo[20494:5183349] 3---{number = 1, name = main}

2018-02-23 22:05:11.799827+0800 YSC-GCD-demo[20494:5183349] 3---{number = 1, name = main}

2018-02-23 22:05:11.799977+0800 YSC-GCD-demo[20494:5183349] group---end

從dispatch_group_notify相關代碼運行輸出結果可以看出：

當所有任務都執行完成之后，才執行dispatch_group_notifyblock 中的任務。

6.5.2 dispatch_group_wait

暫停當前線程（阻塞當前線程），等待指定的 group 中的任務執行完成后，才會往下繼續執行。

/**

* 隊列組 dispatch_group_wait

*/- (void)groupWait {NSLog(@"currentThread---%@",[NSThreadcurrentThread]);// 打印當前線程NSLog(@"group---begin");? ? ? ? dispatch_group_t group =? dispatch_group_create();? ? ? ? dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0), ^{// 追加任務1for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"1---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });? ? ? ? dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0), ^{// 追加任務2for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"2---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? });// 等待上面的任務全部完成后，會往下繼續執行（會阻塞當前線程）dispatch_group_wait(group, DISPATCH_TIME_FOREVER);NSLog(@"group---end");}

輸出結果：

2018-02-23 22:10:16.939258+0800 YSC-GCD-demo[20538:5198871] currentThread---{number = 1, name = main}

2018-02-23 22:10:16.939455+0800 YSC-GCD-demo[20538:5198871] group---begin

2018-02-23 22:10:18.943862+0800 YSC-GCD-demo[20538:5199137] 2---{number = 4, name = (null)}

2018-02-23 22:10:18.943861+0800 YSC-GCD-demo[20538:5199138] 1---{number = 3, name = (null)}

2018-02-23 22:10:20.947787+0800 YSC-GCD-demo[20538:5199137] 2---{number = 4, name = (null)}

2018-02-23 22:10:20.947790+0800 YSC-GCD-demo[20538:5199138] 1---{number = 3, name = (null)}

2018-02-23 22:10:20.948134+0800 YSC-GCD-demo[20538:5198871] 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---%@",[NSThreadcurrentThread]);// 打印當前線程NSLog(@"group---begin");? ? ? ? dispatch_group_t group = dispatch_group_create();dispatch_queue_tqueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);? ? dispatch_group_enter(group);dispatch_async(queue, ^{// 追加任務1for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"1---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? ? ? dispatch_group_leave(group);? ? });? ? ? ? dispatch_group_enter(group);dispatch_async(queue, ^{// 追加任務2for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"2---%@",[NSThreadcurrentThread]);// 打印當前線程}? ? ? ? dispatch_group_leave(group);? ? });? ? ? ? dispatch_group_notify(group, dispatch_get_main_queue(), ^{// 等前面的異步操作都執行完畢后，回到主線程.for(inti =0; i <2; ++i) {? ? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作NSLog(@"3---%@",[NSThreadcurrentThread]);// 打印當前線程}NSLog(@"group---end");? ? });//? ? // 等待上面的任務全部完成后，會往下繼續執行（會阻塞當前線程）//? ? dispatch_group_wait(group, DISPATCH_TIME_FOREVER);////? ? NSLog(@"group---end");}

輸出結果：

2018-02-23 22:14:17.997667+0800 YSC-GCD-demo[20592:5214830] currentThread---{number = 1, name = main}

2018-02-23 22:14:17.997839+0800 YSC-GCD-demo[20592:5214830] group---begin

2018-02-23 22:14:20.000298+0800 YSC-GCD-demo[20592:5215094] 1---{number = 4, name = (null)}

2018-02-23 22:14:20.000305+0800 YSC-GCD-demo[20592:5215095] 2---{number = 3, name = (null)}

2018-02-23 22:14:22.001323+0800 YSC-GCD-demo[20592:5215094] 1---{number = 4, name = (null)}

2018-02-23 22:14:22.001339+0800 YSC-GCD-demo[20592:5215095] 2---{number = 3, name = (null)}

2018-02-23 22:14:24.002321+0800 YSC-GCD-demo[20592:5214830] 3---{number = 1, name = main}

2018-02-23 22:14:26.002852+0800 YSC-GCD-demo[20592:5214830] 3---{number = 1, name = main}

2018-02-23 22:14:26.003116+0800 YSC-GCD-demo[20592:5214830] 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時等待，不可通過。計數為1或大于1時，計數減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 {? ? __blockNSArray*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;? ? ? ? }elseif([keyPath isEqualToString:NSStringFromSelector(@selector(uploadTasks))]) {? ? ? ? ? ? tasks = uploadTasks;? ? ? ? }elseif([keyPath isEqualToString:NSStringFromSelector(@selector(downloadTasks))]) {? ? ? ? ? ? tasks = downloadTasks;? ? ? ? }elseif([keyPath isEqualToString:NSStringFromSelector(@selector(tasks))]) {? ? ? ? ? ? tasks = [@[dataTasks, uploadTasks, downloadTasks] valueForKeyPath:@"@unionOfArrays.self"];? ? ? ? }? ? ? ? dispatch_semaphore_signal(semaphore);? ? }];? ? dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);returntasks;}

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

/**

* semaphore 線程同步

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

輸出結果：

2018-02-23 22:22:26.521665+0800 YSC-GCD-demo[20642:5246341] currentThread---{number = 1, name = main}

2018-02-23 22:22:26.521869+0800 YSC-GCD-demo[20642:5246341] semaphore---begin

2018-02-23 22:22:28.526841+0800 YSC-GCD-demo[20642:5246638] 1---{number = 3, name = (null)}

2018-02-23 22:22:28.527030+0800 YSC-GCD-demo[20642:5246341] semaphore---end,number = 100

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

semaphore---end是在執行完number = 100;之后才打印的。而且輸出結果 number 為 100。

這是因為異步執行不會做任何等待，可以繼續執行任務。異步執行將任務1追加到隊列之后，不做等待，接著執行dispatch_semaphore_wait方法。此時 semaphore == 0，當前線程進入等待狀態。然后，異步任務1開始執行。任務1執行到dispatch_semaphore_signal之后，總信號量，此時 semaphore == 1，dispatch_semaphore_wait方法使總信號量減1，正在被阻塞的線程（主線程）恢復繼續執行。最后打印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---%@",[NSThreadcurrentThread]);// 打印當前線程NSLog(@"semaphore---begin");self.ticketSurplusCount =50;// queue1 代表北京火車票售賣窗口dispatch_queue_tqueue1 = dispatch_queue_create("net.bujige.testQueue1", DISPATCH_QUEUE_SERIAL);// queue2 代表上海火車票售賣窗口dispatch_queue_tqueue2 = dispatch_queue_create("net.bujige.testQueue2", DISPATCH_QUEUE_SERIAL);? ? ? ? __weaktypeof(self) weakSelf =self;dispatch_async(queue1, ^{? ? ? ? [weakSelf saleTicketNotSafe];? ? });dispatch_async(queue2, ^{? ? ? ? [weakSelf saleTicketNotSafe];? ? });}/**

* 售賣火車票(非線程安全)

*/- (void)saleTicketNotSafe {while(1) {if(self.ticketSurplusCount >0) {//如果還有票，繼續售賣self.ticketSurplusCount--;NSLog(@"%@", [NSStringstringWithFormat:@"剩余票數：%d 窗口：%@",self.ticketSurplusCount, [NSThreadcurrentThread]]);? ? ? ? ? ? [NSThreadsleepForTimeInterval:0.2];? ? ? ? }else{//如果已賣完，關閉售票窗口NSLog(@"所有火車票均已售完");break;? ? ? ? }? ? ? ? ? ? }}

輸出結果（部分）：

2018-02-23 22:25:35.789072+0800 YSC-GCD-demo[20712:5258914] currentThread---{number = 1, name = main}

2018-02-23 22:25:35.789260+0800 YSC-GCD-demo[20712:5258914] semaphore---begin

2018-02-23 22:25:35.789641+0800 YSC-GCD-demo[20712:5259176] 剩余票數：48 窗口：{number = 3, name = (null)}

2018-02-23 22:25:35.789646+0800 YSC-GCD-demo[20712:5259175] 剩余票數：49 窗口：{number = 4, name = (null)}

2018-02-23 22:25:35.994113+0800 YSC-GCD-demo[20712:5259175] 剩余票數：47 窗口：{number = 4, name = (null)}

2018-02-23 22:25:35.994129+0800 YSC-GCD-demo[20712:5259176] 剩余票數：46 窗口：{number = 3, name = (null)}

2018-02-23 22:25:36.198993+0800 YSC-GCD-demo[20712:5259176] 剩余票數：45 窗口：{number = 3, name = (null)}

...

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

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

考慮線程安全的代碼：

/**

* 線程安全：使用 semaphore 加鎖

* 初始化火車票數量、賣票窗口(線程安全)、并開始賣票

*/- (void)initTicketStatusSave {NSLog(@"currentThread---%@",[NSThreadcurrentThread]);// 打印當前線程NSLog(@"semaphore---begin");? ? ? ? semaphoreLock = dispatch_semaphore_create(1);self.ticketSurplusCount =50;// queue1 代表北京火車票售賣窗口dispatch_queue_tqueue1 = dispatch_queue_create("net.bujige.testQueue1", DISPATCH_QUEUE_SERIAL);// queue2 代表上海火車票售賣窗口dispatch_queue_tqueue2 = dispatch_queue_create("net.bujige.testQueue2", DISPATCH_QUEUE_SERIAL);? ? ? ? __weaktypeof(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(@"%@", [NSStringstringWithFormat:@"剩余票數：%d 窗口：%@",self.ticketSurplusCount, [NSThreadcurrentThread]]);? ? ? ? ? ? [NSThreadsleepForTimeInterval:0.2];? ? ? ? }else{//如果已賣完，關閉售票窗口NSLog(@"所有火車票均已售完");// 相當于解鎖dispatch_semaphore_signal(semaphoreLock);break;? ? ? ? }// 相當于解鎖dispatch_semaphore_signal(semaphoreLock);? ? }}

輸出結果為：

2018-02-23 22:32:19.814232+0800 YSC-GCD-demo[20862:5290531] currentThread---{number = 1, name = main}

2018-02-23 22:32:19.814412+0800 YSC-GCD-demo[20862:5290531] semaphore---begin

2018-02-23 22:32:19.814837+0800 YSC-GCD-demo[20862:5290687] 剩余票數：49 窗口：{number = 3, name = (null)}

2018-02-23 22:32:20.017745+0800 YSC-GCD-demo[20862:5290689] 剩余票數：48 窗口：{number = 4, name = (null)}

2018-02-23 22:32:20.222039+0800 YSC-GCD-demo[20862:5290687] 剩余票數：47 窗口：{number = 3, name = (null)}

...

2018-02-23 22:32:29.024817+0800 YSC-GCD-demo[20862:5290689] 剩余票數：4 窗口：{number = 4, name = (null)}

2018-02-23 22:32:29.230110+0800 YSC-GCD-demo[20862:5290687] 剩余票數：3 窗口：{number = 3, name = (null)}

2018-02-23 22:32:29.433615+0800 YSC-GCD-demo[20862:5290689] 剩余票數：2 窗口：{number = 4, name = (null)}

2018-02-23 22:32:29.637572+0800 YSC-GCD-demo[20862:5290687] 剩余票數：1 窗口：{number = 3, name = (null)}

2018-02-23 22:32:29.840234+0800 YSC-GCD-demo[20862:5290689] 剩余票數：0 窗口：{number = 4, name = (null)}

2018-02-23 22:32:30.044960+0800 YSC-GCD-demo[20862:5290687] 所有火車票均已售完

2018-02-23 22:32:30.045260+0800 YSC-GCD-demo[20862:5290689] 所有火車票均已售完

可以看出，在考慮了線程安全的情況下，使用dispatch_semaphore

機制之后，得到的票數是正確的，沒有出現混亂的情況。我們也就解決了多個線程同步的問題。

作者：行走的少年郎

鏈接：http://www.lxweimin.com/p/2d57c72016c6

?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。
  • 人面猴
    序言：七十年代末，一起剝皮案震驚了整個濱河市，隨后出現的幾起案子，更是在濱河造成了極大的恐慌，老刑警劉巖，帶你破解...
    沈念sama閱讀 227,818評論 6贊 531
  • 死咒
    序言：濱河連續發生了三起死亡事件，死亡現場離奇詭異，居然都是意外死亡，警方通過查閱死者的電腦和手機，發現死者居然都...
    沈念sama閱讀 98,185評論 3贊 414
  • 救了他兩次的神仙讓他今天三更去死
    文/潘曉璐 我一進店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來，“玉大人，你說我怎么就攤上這事。” “怎么了？”我有些...
    開封第一講書人閱讀 175,656評論 0贊 373
  • 道士緝兇錄：失蹤的賣姜人
    文/不壞的土叔 我叫張陵，是天一觀的道長。 經常有香客問我，道長，這世上最難降的妖魔是什么？ 我笑而不...
    開封第一講書人閱讀 62,647評論 1贊 309
  • ?港島之戀（遺憾婚禮）
    正文 為了忘掉前任，我火速辦了婚禮，結果婚禮上，老公的妹妹穿的比我還像新娘。我一直安慰自己，他們只是感情好，可當我...
    茶點故事閱讀 71,446評論 6贊 405
  • 惡毒庶女頂嫁案：這布局不是一般人想出來的
    文/花漫 我一把揭開白布。 她就那樣靜靜地躺著，像睡著了一般。 火紅的嫁衣襯著肌膚如雪。 梳的紋絲不亂的頭發上，一...
    開封第一講書人閱讀 54,951評論 1贊 321
  • 城市分裂傳說
    那天，我揣著相機與錄音，去河邊找鬼。 笑死，一個胖子當著我的面吹牛，可吹牛的內容都是我干的。 我是一名探鬼主播，決...
    沈念sama閱讀 43,041評論 3贊 440
  • 雙鴛鴦連環套：你想象不到人心有多黑
    文/蒼蘭香墨 我猛地睜開眼，長吁一口氣：“原來是場噩夢啊……” “哼！你這毒婦竟也來了？” 一聲冷哼從身側響起，我...
    開封第一講書人閱讀 42,189評論 0贊 287
  • 萬榮殺人案實錄
    序言：老撾萬榮一對情侶失蹤，失蹤者是張志新（化名）和其女友劉穎，沒想到半個月后，有當地人在樹林里發現了一具尸體，經...
    沈念sama閱讀 48,718評論 1贊 333
  • ?護林員之死
    正文 獨居荒郊野嶺守林人離奇死亡，尸身上長有42處帶血的膿包…… 初始之章·張勛 以下內容為張勛視角 年9月15日...
    茶點故事閱讀 40,602評論 3贊 354
  • ?白月光啟示錄
    正文 我和宋清朗相戀三年，在試婚紗的時候發現自己被綠了。 大學時的朋友給我發了我未婚夫和他白月光在一起吃飯的照片。...
    茶點故事閱讀 42,800評論 1贊 369
  • 活死人
    序言：一個原本活蹦亂跳的男人離奇死亡，死狀恐怖，靈堂內的尸體忽然破棺而出，到底是詐尸還是另有隱情，我是刑警寧澤，帶...
    沈念sama閱讀 38,316評論 5贊 358
  • ?日本核電站爆炸內幕
    正文 年R本政府宣布，位于F島的核電站，受9級特大地震影響，放射性物質發生泄漏。R本人自食惡果不足惜，卻給世界環境...
    茶點故事閱讀 44,045評論 3贊 347
  • 男人毒藥：我在死后第九天來索命
    文/蒙蒙 一、第九天 我趴在偏房一處隱蔽的房頂上張望。 院中可真熱鬧，春花似錦、人聲如沸。這莊子的主人今日做“春日...
    開封第一講書人閱讀 34,419評論 0贊 26
  • 一樁弒父案，背后竟有這般陰謀
    文/蒼蘭香墨 我抬頭看了看天上的太陽。三九已至，卻和暖如春，著一層夾襖步出監牢的瞬間，已是汗流浹背。 一陣腳步聲響...
    開封第一講書人閱讀 35,671評論 1贊 281
  • 情欲美人皮
    我被黑心中介騙來泰國打工， 沒想到剛下飛機就差點兒被人妖公主榨干…… 1. 我叫王不留，地道東北人。 一個月前我還...
    沈念sama閱讀 51,420評論 3贊 390
  • 代替公主和親
    正文 我出身青樓，卻偏偏與公主長得像，于是被迫代替她去往敵國和親。 傳聞我的和親對象是個殘疾皇子，可洞房花燭夜當晚...
    茶點故事閱讀 47,755評論 2贊 371

推薦閱讀更多精彩內容

  • 目錄 上一章 尾聲 一．想說的話 我想寫些深刻的東西，文字假裝老練，見識其實薄淺。 我寫序章時腦中浮想聯翩，為“舊...
    景泰藍呦閱讀 258評論 0贊 0
  • 安裝 配置 在main.js中配置 就是把插件對象加到vue的原型上去，訪問的時候記得是this.$http.xx...
    BrotherWy閱讀 482評論 0贊 0
  • 作者/老大不小的少女心
    夏檸shining_閱讀 295評論 0贊 1
  • ——寫給自己的一封信 親愛的自己： 你好！ 我看見你了，別跑。你站在晾曬的麥子上，抬起頭，用力把手中的麥子向上揚起...
    盈袖格閱讀 375評論 1贊 2