?原文鏈接：http://www.itdecent.cn/p/2d57c72016c6
本文用來介紹 iOS 多線程中 GCD 的相關(guān)知識以及使用方法。通過本文，您將了解到：
1. GCD 簡介
2. GCD 任務(wù)和隊列
3. GCD 的使用步驟
4. GCD 的基本使用（6種不同組合區(qū)別）
1. GCD 簡介
什么是 GCD 呢？我們先來看看百度百科的解釋簡單了解下概念
引自百度百科
Grand Central Dispatch(GCD)是 Apple 開發(fā)的一個多核編程的較新的解決方法。它主要用于優(yōu)化應(yīng)用程序以支持多核處理器以及其他對稱多處理系統(tǒng)。它是一個在線程池模式的基礎(chǔ)上執(zhí)行的并發(fā)任務(wù)。在 Mac OS X 10.6 雪豹中首次推出，也可在 iOS 4 及以上版本使用。
為什么要用 GCD 呢？
因為 GCD 有很多好處啊，具體如下：
GCD 可用于多核的并行運算
GCD 會自動利用更多的 CPU 內(nèi)核（比如雙核、四核）
GCD 會自動管理線程的生命周期（創(chuàng)建線程、調(diào)度任務(wù)、銷毀線程）
程序員只需要告訴 GCD 想要執(zhí)行什么任務(wù)，不需要編寫任何線程管理代碼
既然 GCD 有這么多的好處，那么下面我們就來系統(tǒng)的學習一下 GCD 的使用方法。
2. GCD 任務(wù)和隊列
學習 GCD 之前，先來了解 GCD 中兩個核心概念：任務(wù)和隊列。
任務(wù)：就是執(zhí)行操作的意思，換句話說就是你在線程中執(zhí)行的那段代碼。在 GCD 中是放在 block 中的。執(zhí)行任務(wù)有兩種方式：同步執(zhí)行（sync）和異步執(zhí)行（async）。兩者的主要區(qū)別是：是否等待隊列的任務(wù)執(zhí)行結(jié)束，以及是否具備開啟新線程的能力。
同步執(zhí)行（sync）：
同步添加任務(wù)到指定的隊列中，在添加的任務(wù)執(zhí)行結(jié)束之前，會一直等待，直到隊列里面的任務(wù)完成之后再繼續(xù)執(zhí)行。
只能在當前線程中執(zhí)行任務(wù)，不具備開啟新線程的能力。
異步執(zhí)行（async）：
異步添加任務(wù)到指定的隊列中，它不會做任何等待，可以繼續(xù)執(zhí)行任務(wù)。
可以在新的線程中執(zhí)行任務(wù)，具備開啟新線程的能力。
舉個簡單例子：你要打電話給小明和小白。
同步執(zhí)行就是，你打電話給小明的時候，不能同時打給小白，等到給小明打完了，才能打給小白（等待任務(wù)執(zhí)行結(jié)束）。而且只能用當前的電話（不具備開啟新線程的能力）。
而異步執(zhí)行就是，你打電話給小明的時候，不等和小明通話結(jié)束，還能直接給小白打電話，不用等著和小明通話結(jié)束再打（不用等待任務(wù)執(zhí)行結(jié)束）。除了當前電話，你還可以使用其他所能使用的電話（具備開啟新線程的能力）。
注意：異步執(zhí)行（async）雖然具有開啟新線程的能力，但是并不一定開啟新線程。這跟任務(wù)所指定的隊列類型有關(guān)（下面會講）。
隊列（Dispatch Queue）：這里的隊列指執(zhí)行任務(wù)的等待隊列，即用來存放任務(wù)的隊列。隊列是一種特殊的線性表，采用 FIFO（先進先出）的原則，即新任務(wù)總是被插入到隊列的末尾，而讀取任務(wù)的時候總是從隊列的頭部開始讀取。每讀取一個任務(wù)，則從隊列中釋放一個任務(wù)。隊列的結(jié)構(gòu)可參考下圖：
在 GCD 中有兩種隊列：串行隊列和并發(fā)隊列。兩者都符合 FIFO（先進先出）的原則。兩者的主要區(qū)別是：執(zhí)行順序不同，以及開啟線程數(shù)不同。
串行隊列（Serial Dispatch Queue）：
每次只有一個任務(wù)被執(zhí)行。讓任務(wù)一個接著一個地執(zhí)行。（只開啟一個線程，一個任務(wù)執(zhí)行完畢后，再執(zhí)行下一個任務(wù)）
并發(fā)隊列（Concurrent Dispatch Queue）：
可以讓多個任務(wù)并發(fā)（同時）執(zhí)行。（可以開啟多個線程，并且同時執(zhí)行任務(wù)）
注意：并發(fā)隊列的并發(fā)功能只有在異步（dispatch_async）函數(shù)下才有效
兩者具體區(qū)別如下兩圖所示。
串行隊列.png
并發(fā)隊列.png
3. GCD 的使用步驟
GCD 的使用步驟其實很簡單，只有兩步。
1.創(chuàng)建一個隊列（串行隊列或并發(fā)隊列）
2.將任務(wù)追加到任務(wù)的等待隊列中，然后系統(tǒng)就會根據(jù)任務(wù)類型執(zhí)行任務(wù)（同步執(zhí)行或異步執(zhí)行）
下邊來看看隊列的創(chuàng)建方法/獲取方法，以及任務(wù)的創(chuàng)建方法。
3.1 隊列的創(chuàng)建方法/獲取方法
可以使用dispatch_queue_create來創(chuàng)建隊列，需要傳入兩個參數(shù)，第一個參數(shù)表示隊列的唯一標識符，用于 DEBUG，可為空，Dispatch Queue 的名稱推薦使用應(yīng)用程序 ID 這種逆序全程域名；第二個參數(shù)用來識別是串行隊列還是并發(fā)隊列。DISPATCH_QUEUE_SERIAL表示串行隊列，DISPATCH_QUEUE_CONCURRENT表示并發(fā)隊列。
// 串行隊列的創(chuàng)建方法dispatch_queue_tqueue= dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
// 并發(fā)隊列的創(chuàng)建方法dispatch_queue_tqueue= dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
對于串行隊列，GCD 提供了的一種特殊的串行隊列：主隊列（Main Dispatch Queue）。
a.所有放在主隊列中的任務(wù)，都會放到主線程中執(zhí)行。
b.可使用dispatch_get_main_queue()獲得主隊列。
// 主隊列的獲取方法
dispatch_queue_t queue= dispatch_get_main_queue();
對于并發(fā)隊列，GCD 默認提供了全局并發(fā)隊列（Global Dispatch Queue）。
a.可以使用dispatch_get_global_queue來獲取。需要傳入兩個參數(shù)。第一個參數(shù)表示隊列優(yōu)先級，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二個參數(shù)暫時沒用，用0即可。
// 全局并發(fā)隊列的獲取方法
dispatch_queue_tqueue= dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);
3.2 任務(wù)的創(chuàng)建方法
GCD 提供了同步執(zhí)行任務(wù)的創(chuàng)建方法dispatch_sync和異步執(zhí)行任務(wù)創(chuàng)建方法dispatch_async。
// 同步執(zhí)行任務(wù)創(chuàng)建方法
dispatch_sync(queue, ^{// 這里放同步執(zhí)行任務(wù)代碼});
// 異步執(zhí)行任務(wù)創(chuàng)建方法
dispatch_async(queue, ^{// 這里放異步執(zhí)行任務(wù)代碼});
雖然使用 GCD 只需兩步，但是既然我們有兩種隊列（串行隊列/并發(fā)隊列），兩種任務(wù)執(zhí)行方式（同步執(zhí)行/異步執(zhí)行），那么我們就有了四種不同的組合方式。這四種不同的組合方式是：
同步執(zhí)行 + 并發(fā)隊列
異步執(zhí)行 + 并發(fā)隊列
同步執(zhí)行 + 串行隊列
異步執(zhí)行 + 串行隊列
實際上，剛才還說了兩種特殊隊列：全局并發(fā)隊列、主隊列。全局并發(fā)隊列可以作為普通并發(fā)隊列來使用。但是主隊列因為有點特殊，所以我們就又多了兩種組合方式。這樣就有六種不同的組合方式了。
同步執(zhí)行 + 主隊列
異步執(zhí)行 + 主隊列
那么這幾種不同組合方式各有什么區(qū)別呢，這里為了方便，先上結(jié)果，再來講解。你可以直接查看表格結(jié)果，然后跳過4. GCD的基本使用。
下邊我們來分別講講這幾種不同的組合方式的使用方法。
4. GCD 的基本使用
先來講講并發(fā)隊列的兩種執(zhí)行方式。
4.1 同步執(zhí)行 + 并發(fā)隊列
在當前線程中執(zhí)行任務(wù)，不會開啟新線程，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。
/**
* 同步執(zhí)行 + 并發(fā)隊列
* 特點：在當前線程中執(zhí)行任務(wù)，不會開啟新線程，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。
*/
- (void)syncConcurrent {
NSLog(@"currentThread---%@",[NSThreadcurrentThread]);
// 打印當前線程NSLog(@"syncConcurrent---begin");
dispatch_queue_tqueue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_sync(queue, ^{
? ?// 追加任務(wù)1
? ?for(inti =0; i <2; ++i) {? ? ? ? ?
? ? ? ?[NSThreadsleepForTimeInterval:2];// 模擬耗時操作
? ? ? ? NSLog(@"1---%@",[NSThreadcurrentThread]);// 打印當前線程
? ? }?
? });
dispatch_sync(queue, ^{
? ? ? // 追加任務(wù)2
? ? ? for(inti =0; i <2; ++i) {? ? ? ?
? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作
? ? ? ? NSLog(@"2---%@",[NSThreadcurrentThread]);// 打印當前線程
? ? ? ?}? ?
});
dispatch_sync(queue, ^{
? ? // 追加任務(wù)3
? ? for(inti =0; i <2; ++i) {? ? ?
? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作
? ? ? NSLog(@"3---%@",[NSThreadcurrentThread]);// 打印當前線程
? ? }?
? });
NSLog(@"syncConcurrent---end");}
輸出結(jié)果：
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
從同步執(zhí)行 + 并發(fā)隊列中可看到：
a.所有任務(wù)都是在當前線程（主線程）中執(zhí)行的，沒有開啟新的線程（同步執(zhí)行不具備開啟新線程的能力）。
b.所有任務(wù)都在打印的syncConcurrent---begin和syncConcurrent---end之間執(zhí)行的（同步任務(wù)需要等待隊列的任務(wù)執(zhí)行結(jié)束）。
任務(wù)按順序執(zhí)行的。按順序執(zhí)行的原因：雖然并發(fā)隊列可以開啟多個線程，并且同時執(zhí)行多個任務(wù)。但是因為本身不能創(chuàng)建新線程，只有當前線程這一個線程（同步任務(wù)不具備開啟新線程的能力），所以也就不存在并發(fā)。而且當前線程只有等待當前隊列中正在執(zhí)行的任務(wù)執(zhí)行完畢之后，才能繼續(xù)接著執(zhí)行下面的操作（同步任務(wù)需要等待隊列的任務(wù)執(zhí)行結(jié)束）。所以任務(wù)只能一個接一個按順序執(zhí)行，不能同時被執(zhí)行。
4.2 異步執(zhí)行 + 并發(fā)隊列
可以開啟多個線程，任務(wù)交替（同時）執(zhí)行。
/**
* 異步執(zhí)行 + 并發(fā)隊列
* 特點：可以開啟多個線程，任務(wù)交替（同時）執(zhí)行。
*/- (void)asyncConcurrent {
NSLog(@"currentThread---%@",[NSThreadcurrentThread]);
// 打印當前線程NSLog(@"asyncConcurrent---begin");
dispatch_queue_tqueue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
// 追加任務(wù)1for(inti =0; i <2; ++i) {?
? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作
NSLog(@"1---%@",[NSThreadcurrentThread]);// 打印當前線程}?
? });
dispatch_async(queue, ^{
? ? // 追加任務(wù)2
? ? for(inti =0; i <2; ++i) {? ? ? ? ?
? ? ? ?[NSThreadsleepForTimeInterval:2];// 模擬耗時操作
? ? ? ?NSLog(@"2---%@",[NSThreadcurrentThread]);// 打印當前線程
? ? ?}? ?
});
dispatch_async(queue, ^{
? ? // 追加任務(wù)3
? ? ? ?for(inti =0; i <2; ++i) {? ? ?
? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作
? ? ? NSLog(@"3---%@",[NSThreadcurrentThread]);// 打印當前線程
? ? ? }?
? });
NSLog(@"asyncConcurrent---end");}
輸出結(jié)果：
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)}
在異步執(zhí)行 + 并發(fā)隊列中可以看出：
a.除了當前線程（主線程），系統(tǒng)又開啟了3個線程，并且任務(wù)是交替/同時執(zhí)行的。（異步執(zhí)行具備開啟新線程的能力。且并發(fā)隊列可開啟多個線程，同時執(zhí)行多個任務(wù)）。
b.所有任務(wù)是在打印的syncConcurrent---begin和syncConcurrent---end之后才執(zhí)行的。說明當前線程沒有等待，而是直接開啟了新線程，在新線程中執(zhí)行任務(wù)（異步執(zhí)行不做等待，可以繼續(xù)執(zhí)行任務(wù)）。
接下來再來講講串行隊列的兩種執(zhí)行方式。
4.3 同步執(zhí)行 + 串行隊列
不會開啟新線程，在當前線程執(zhí)行任務(wù)。任務(wù)是串行的，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。
/**
* 同步執(zhí)行 + 串行隊列
* 特點：不會開啟新線程，在當前線程執(zhí)行任務(wù)。任務(wù)是串行的，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。
*/
- (void)syncSerial {
NSLog(@"currentThread---%@",[NSThreadcurrentThread]);// 打印當前線程
NSLog(@"syncSerial---begin");
dispatch_queue_tqueue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
dispatch_sync(queue, ^{
? ? ?// 追加任務(wù)1
? ? ? for(inti =0; i <2; ++i) {? ? ?
? ? ? ? ? ?[NSThreadsleepForTimeInterval:2];// 模擬耗時操作
? ? ? ? ? ?NSLog(@"1---%@",[NSThreadcurrentThread]);// 打印當前線程
? ? ? ? }?
? });
dispatch_sync(queue, ^{
// 追加任務(wù)2
? ? ? for(inti =0; i <2; ++i) {? ?
? ? ? ? ? ?[NSThreadsleepForTimeInterval:2];// 模擬耗時操作
? ? ? ? ? ?NSLog(@"2---%@",[NSThreadcurrentThread]);// 打印當前線程
? ? ? ?}?
? });
dispatch_sync(queue, ^{
// 追加任務(wù)3
? ? for(inti =0; i <2; ++i) {? ? ?
? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作
? ? ? ?NSLog(@"3---%@",[NSThreadcurrentThread]);// 打印當前線程
? ? ?}? ?
});
NSLog(@"syncSerial---end");}
輸出結(jié)果為：
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
在同步執(zhí)行 + 串行隊列可以看到：
a.所有任務(wù)都是在當前線程（主線程）中執(zhí)行的，并沒有開啟新的線程（同步執(zhí)行不具備開啟新線程的能力）。
b.所有任務(wù)都在打印的syncConcurrent---begin和syncConcurrent---end之間執(zhí)行（同步任務(wù)需要等待隊列的任務(wù)執(zhí)行結(jié)束）。
c.任務(wù)是按順序執(zhí)行的（串行隊列每次只有一個任務(wù)被執(zhí)行，任務(wù)一個接一個按順序執(zhí)行）。
4.4 異步執(zhí)行 + 串行隊列
會開啟新線程，但是因為任務(wù)是串行的，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)
/**
* 異步執(zhí)行 + 串行隊列
* 特點：會開啟新線程，但是因為任務(wù)是串行的，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。
*/
- (void)asyncSerial {
NSLog(@"currentThread---%@",[NSThreadcurrentThread]);// 打印當前線程
NSLog(@"asyncSerial---begin");
dispatch_queue_tqueue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{
? ? ?// 追加任務(wù)1
? ? for(inti =0; i <2; ++i) {? ? ? ?
? ? ? ?[NSThreadsleepForTimeInterval:2];// 模擬耗時操作
? ? ? ?NSLog(@"1---%@",[NSThreadcurrentThread]);// 打印當前線程
? ? ? }? ?
});
dispatch_async(queue, ^{
? ? // 追加任務(wù)2
? ? for(int i =0; i <2; ++i) {? ? ? ? ? ?
? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作
? ? ? ? NSLog(@"2---%@",[NSThreadcurrentThread]);// 打印當前線程
? ? ? }?
? });
dispatch_async(queue, ^{
? ? ?// 追加任務(wù)3
? ? ?for(int i =0; i <2; ++i) {? ? ? ? ?
? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作
? ? ? ?NSLog(@"3---%@",[NSThreadcurrentThread]);// 打印當前線程
? ? ? }?
? });
NSLog(@"asyncSerial---end");}
輸出結(jié)果為：
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)}
在異步執(zhí)行 + 串行隊列可以看到：
a.開啟了一條新線程（異步執(zhí)行具備開啟新線程的能力，串行隊列只開啟一個線程）。
b.所有任務(wù)是在打印的syncConcurrent---begin和syncConcurrent---end之后才開始執(zhí)行的（異步執(zhí)行不會做任何等待，可以繼續(xù)執(zhí)行任務(wù)）。
c.任務(wù)是按順序執(zhí)行的（串行隊列每次只有一個任務(wù)被執(zhí)行，任務(wù)一個接一個按順序執(zhí)行）。
下邊講講剛才我們提到過的特殊隊列：主隊列。
主隊列：GCD自帶的一種特殊的串行隊列
所有放在主隊列中的任務(wù)，都會放到主線程中執(zhí)行
可使用dispatch_get_main_queue()獲得主隊列
我們再來看看主隊列的兩種組合方式。
4.5 同步執(zhí)行 + 主隊列
同步執(zhí)行 + 主隊列在不同線程中調(diào)用結(jié)果也是不一樣，在主線程中調(diào)用會出現(xiàn)死鎖，而在其他線程中則不會。
4.5.1 在主線程中調(diào)用同步執(zhí)行 + 主隊列
互相等待卡住不可行
/**
* 同步執(zhí)行 + 主隊列
* 特點(主線程調(diào)用)：互等卡主不執(zhí)行。
* 特點(其他線程調(diào)用)：不會開啟新線程，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。
*/
- (void)syncMain {
NSLog(@"currentThread---%@",[NSThreadcurrentThread]);
// 打印當前線程
NSLog(@"syncMain---begin");
dispatch_queue_tqueue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
? ? ?// 追加任務(wù)1
? ? ?for(inti =0; i <2; ++i) {?
? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作
? ? ? ? ? ?NSLog(@"1---%@",[NSThreadcurrentThread]);// 打印當前線程
? ? ?}? ?
});
dispatch_sync(queue, ^{
? ? ?// 追加任務(wù)2
? ? ? for(inti =0; i <2; ++i) {? ?
? ? ? ? ?[NSThreadsleepForTimeInterval:2];// 模擬耗時操作
? ? ? ? ?NSLog(@"2---%@",[NSThreadcurrentThread]);// 打印當前線程
? ? ? ?}? ?
});
dispatch_sync(queue, ^{
? ? ? // 追加任務(wù)3
? ? ? for(inti =0; i <2; ++i) {? ?
? ? ? ? ? [NSThreadsleepForTimeInterval:2];// 模擬耗時操作
? ? ? ? ? NSLog(@"3---%@",[NSThreadcurrentThread]);// 打印當前線程
? ? ? ?}? ?
});
NSLog(@"syncMain---end");}
輸出結(jié)果
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)
在同步執(zhí)行 + 主隊列可以驚奇的發(fā)現(xiàn)：
在主線程中使用同步執(zhí)行 + 主隊列，追加到主線程的任務(wù)1、任務(wù)2、任務(wù)3都不再執(zhí)行了，而且syncMain---end也沒有打印，在XCode 9上還會報崩潰。這是為什么呢？
這是因為我們在主線程中執(zhí)行syncMain方法，相當于把syncMain任務(wù)放到了主線程的隊列中。而同步執(zhí)行會等待當前隊列中的任務(wù)執(zhí)行完畢，才會接著執(zhí)行。那么當我們把任務(wù)1追加到主隊列中，任務(wù)1就在等待主線程處理完syncMain任務(wù)。而syncMain任務(wù)需要等待任務(wù)1執(zhí)行完畢，才能接著執(zhí)行。
那么，現(xiàn)在的情況就是syncMain任務(wù)和任務(wù)1都在等對方執(zhí)行完畢。這樣大家互相等待，所以就卡住了，所以我們的任務(wù)執(zhí)行不了，而且syncMain---end也沒有打印。
要是如果不在主線程中調(diào)用，而在其他線程中調(diào)用會如何呢？
4.5.2 在其他線程中調(diào)用同步執(zhí)行 + 主隊列
不會開啟新線程，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)
// 使用 NSThread 的 detachNewThreadSelector 方法會創(chuàng)建線程，并自動啟動線程執(zhí)行selector 任務(wù)[NSThread detachNewThreadSelector:@selector(syncMain) toTarget:selfwithObject:nil];
輸出結(jié)果：
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
在其他線程中使用同步執(zhí)行 + 主隊列可看到：
a.所有任務(wù)都是在主線程（非當前線程）中執(zhí)行的，沒有開啟新的線程（所有放在主隊列中的任務(wù)，都會放到主線程中執(zhí)行）。
b.所有任務(wù)都在打印的syncConcurrent---begin和syncConcurrent---end之間執(zhí)行（同步任務(wù)需要等待隊列的任務(wù)執(zhí)行結(jié)束）。
c.任務(wù)是按順序執(zhí)行的（主隊列是串行隊列，每次只有一個任務(wù)被執(zhí)行，任務(wù)一個接一個按順序執(zhí)行）。
為什么現(xiàn)在就不會卡住了呢？
因為syncMain 任務(wù)放到了其他線程里，而任務(wù)1、任務(wù)2、任務(wù)3都在追加到主隊列中，這三個任務(wù)都會在主線程中執(zhí)行。syncMain 任務(wù)在其他線程中執(zhí)行到追加任務(wù)1到主隊列中，因為主隊列現(xiàn)在沒有正在執(zhí)行的任務(wù)，所以，會直接執(zhí)行主隊列的任務(wù)1，等任務(wù)1執(zhí)行完畢，再接著執(zhí)行任務(wù)2、任務(wù)3。所以這里不會卡住線程。
4.6 異步執(zhí)行 + 主隊列
只在主線程中執(zhí)行任務(wù)，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。
/**
* 異步執(zhí)行 + 主隊列
* 特點：只在主線程中執(zhí)行任務(wù)，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)
*/
- (void)asyncMain {
NSLog(@"currentThread---%@",[NSThreadcurrentThread]);// 打印當前線程
NSLog(@"asyncMain---begin");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_async(queue, ^{
? ? ?// 追加任務(wù)1
? ? ? for(int i =0; i <2; ++i) {? ? ?
? ? ? ? [NSThread sleepForTimeInterval:2];// 模擬耗時操作
? ? ? ? ?NSLog(@"1---%@",[NSThread currentThread]);// 打印當前線程
? ? ? }? ?
});
dispatch_async(queue, ^{
? ? // 追加任務(wù)2
? ? for(int i =0; i <2; ++i) {? ?
? ? ? ? [NSThread sleepForTimeInterval:2];// 模擬耗時操作
? ? ? ? NSLog(@"2---%@",[NSThread currentThread]);// 打印當前線程
? ? ? ?}?
?});
dispatch_async(queue, ^{
? ? ? // 追加任務(wù)3
? ? ? ?for(int i =0; i <2; ++i) {? ? ?
? ? ? ? ? ? [NSThread sleepForTimeInterval:2];// 模擬耗時操作
? ? ? ? ? ? ?NSLog(@"3---%@",[NSThread currentThread]);// 打印當前線程
? ? ? ?}? ?
});
NSLog(@"asyncMain---end");}
輸出結(jié)果：
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}
在異步執(zhí)行 + 主隊列可以看到：
a.所有任務(wù)都是在當前線程（主線程）中執(zhí)行的，并沒有開啟新的線程（雖然異步執(zhí)行具備開啟線程的能力，但因為是主隊列，所以所有任務(wù)都在主線程中）。
b.所有任務(wù)是在打印的syncConcurrent---begin和syncConcurrent---end之后才開始執(zhí)行的（異步執(zhí)行不會做任何等待，可以繼續(xù)執(zhí)行任務(wù)）。
c.任務(wù)是按順序執(zhí)行的（因為主隊列是串行隊列，每次只有一個任務(wù)被執(zhí)行，任務(wù)一個接一個按順序執(zhí)行）。
弄懂了難理解、繞來繞去的隊列+任務(wù)之后，我們來學習一個簡單的東西：5. GCD 線程間的通信。
