GCD 详细讲解
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（先進先出）的原則，即新任務總是被插入到隊列的末尾，而讀取任務的時候總是從隊列的頭部開始讀取。每讀取一個任務，則從隊列中釋放一個任務。隊列的結構可參考下圖：
在 GCD 中有兩種隊列：串行隊列和并發隊列。兩者都符合 FIFO（先進先出）的原則。兩者的主要區別是：執行順序不同，以及開啟線程數不同。串行隊列（Serial Dispatch Queue）：
每次只有一個任務被執行。讓任務一個接著一個地執行。（只開啟一個線程，一個任務執行完畢后，再執行下一個任務）
并發隊列（Concurrent Dispatch Queue）：
可以讓多個任務并發（同時）執行。（可以開啟多個線程，并且同時執行任務）
注意：并發隊列 的并發功能只有在異步（dispatch_async）函數下才有效
兩者具體區別如下兩圖所示。
3. GCD 的使用步驟
GCD 的使用步驟其實很簡單，只有兩步。
創建一個隊列（串行隊列或并發隊列）
將任務追加到任務的等待隊列中，然后系統就會根據任務類型執行任務（同步執行或異步執行）
下邊來看看 隊列的創建方法/獲取方法，以及 任務的創建方法。
3.1 隊列的創建方法/獲取方法
可以使用dispatch_queue_create來創建隊列，需要傳入兩個參數，第一個參數表示隊列的唯一標識符，用于 DEBUG，可為空，Dispatch Queue 的名稱推薦使用應用程序 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);
//?主隊列的獲取方法dispatch_queue_t?queue?=?dispatch_get_main_queue();
//?全局并發隊列的獲取方法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.異步執行 + 串行隊列
實際上，剛才還說了兩種特殊隊列：全局并發隊列、主隊列。全局并發隊列可以作為普通并發隊列來使用。但是主隊列因為有點特殊，所以我們就又多了兩種組合方式。這樣就有六種不同的組合方式了。
5.同步執行 + 主隊列
6.異步執行 + 主隊列
那么這幾種不同組合方式各有什么區別呢，這里為了方便，先上結果，再來講解。你可以直接查看表格結果，然后跳過 4. 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????????for?(int?i?=?0;?i?
輸出結果：
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—%@”,[NSThread?currentThread]);??//?打印當前線程????NSLog(@”asyncConcurrent—begin”);????????dispatch_queue_t?queue?=?dispatch_queue_create(“net.bujige.testQueue”,?DISPATCH_QUEUE_CONCURRENT);????????dispatch_async(queue,?^{????????//?追加任務1????????for?(int?i?=?0;?i?
輸出結果：
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—%@”,[NSThread?currentThread]);??//?打印當前線程????NSLog(@”syncSerial—begin”);????????dispatch_queue_t?queue?=?dispatch_queue_create(“net.bujige.testQueue”,?DISPATCH_QUEUE_SERIAL);????????dispatch_sync(queue,?^{????????//?追加任務1????????for?(int?i?=?0;?i?
輸出結果：
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—%@”,[NSThread?currentThread]);??//?打印當前線程????NSLog(@”asyncSerial—begin”);????????dispatch_queue_t?queue?=?dispatch_queue_create(“net.bujige.testQueue”,?DISPATCH_QUEUE_SERIAL);????????dispatch_async(queue,?^{????????//?追加任務1????????for?(int?i?=?0;?i?
輸出結果：
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之后才開始執行的（異步執行不會做任何等待，可以繼續執行任務）。
任務是按順序執行的（串行隊列每次只有一個任務被執行，任務一個接一個按順序執行）。
下邊講講剛才我們提到過的特殊隊列：主隊列。
我們再來看看主隊列的兩種組合方式。
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????????for?(int?i?=?0;?i?
輸出結果：
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)
在同步執行 + 主隊列可以驚奇的發現：
這是因為我們在主線程中執行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];
輸出結果：
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—%@”,[NSThread?currentThread]);??//?打印當前線程????NSLog(@”asyncMain—begin”);????????dispatch_queue_t?queue?=?dispatch_get_main_queue();????????dispatch_async(queue,?^{????????//?追加任務1????????for?(int?i?=?0;?i?
輸出結果：
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_t?queue?=?dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,?0);?????//?獲取主隊列????dispatch_queue_t?mainQueue?=?dispatch_get_main_queue();?????????dispatch_async(queue,?^{????????//?異步追加任務????????for?(int?i?=?0;?i?
輸出結果：
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?/-?(void)barrier?{????dispatch_queue_t?queue?=?dispatch_queue_create(“net.bujige.testQueue”,?DISPATCH_QUEUE_CONCURRENT);????????dispatch_async(queue,?^{????????//?追加任務1????????for?(int?i?=?0;?i?
輸出結果：
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—%@”,[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]);??//?打印當前線程????});}
輸出結果：
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}
在dispatch_after相關代碼執行結果中可以看出：在打印 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?{????static?dispatch_once_t?onceToken;????dispatch_once(&onceToken,?^{????????//?只執行1次的代碼(這里面默認是線程安全的)????});}
6.4 GCD 快速迭代方法：dispatch_apply
我們可以利用異步隊列同時遍歷。比如說遍歷 0~5 這6個數字，for 循環的做法是每次取出一個元素，逐個遍歷。dispatch_apply可以同時遍歷多個數字。
/??快速迭代方法?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”);}
輸出結果：
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
從dispatch_apply相關代碼執行結果中可以看出：
因為是在并發隊列中異步隊執行任務，所以各個任務的執行時間長短不定，最后結束順序也不定。但是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
/??隊列組?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????????for?(int?i?=?0;?i?
輸出結果：
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_notify block 中的任務。
6.5.2 dispatch_group_wait
/??隊列組?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????????for?(int?i?=?0;?i?
輸出結果：
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—%@”,[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????????for?(int?i?=?0;?i?
輸出結果：
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?{????__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);}
輸出結果：
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—%@”,[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;????????}????????????}}
輸出結果（部分）：
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—%@”,[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);????}}
輸出結果為：
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?機制之后，得到的票數是正確的，沒有出現混亂的情況。我們也就解決了多個線程同步的問題。
總結
- 上一篇： 科普：卡他妈滤波_拔剑-浆糊的传说_新浪
- 下一篇： 听乔布斯演讲有感