国产国语对白露脸正在播放,国产精品先锋资源站先锋影院,亚洲AV成人一区国产精品

什么是 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 會自動利用更多的 CPU 內(nèi)核（比如雙核、四核） GCD 會自動管理線程的生命周期（創(chuàng)建線程、調(diào)度任務(wù)、銷毀線程）程序員只需要告訴 GCD 想要執(zhí)行什么任務(wù)，不需要編寫任何線程管理代碼

既然 GCD 有這么多的好處，那么下面我們就來系統(tǒng)的學(xué)習(xí)一下 GCD 的使用方法。

學(xué)習(xí) 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í)行。只能在當(dāng)前線程中執(zhí)行任務(wù)，不具備開啟新線程的能力。異步執(zhí)行（async）：異步添加任務(wù)到指定的隊列中，它不會做任何等待，可以繼續(xù)執(zhí)行任務(wù)。可以在新的線程中執(zhí)行任務(wù)，具備開啟新線程的能力。

舉個簡單例子：你要打電話給小明和小白。
同步執(zhí)行就是，你打電話給小明的時候，不能同時打給小白，等到給小明打完了，才能打給小白（等待任務(wù)執(zhí)行結(jié)束）。而且只能用當(dāng)前的電話（不具備開啟新線程的能力）。
而異步執(zhí)行就是，你打電話給小明的時候，不等和小明通話結(jié)束，還能直接給小白打電話，不用等著和小明通話結(jié)束再打（不用等待任務(wù)執(zhí)行結(jié)束）。除了當(dāng)前電話，你還可以使用其他所能使用的電話（具備開啟新線程的能力）。

注意：異步執(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ù)下才有效

創(chuàng)建一個隊列（串行隊列或并發(fā)隊列）將任務(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ù)表示隊列的唯一標(biāo)識符，用于 DEBUG，可為空，Dispatch Queue 的名稱推薦使用應(yīng)用程序 ID 這種逆序全程域名；第二個參數(shù)用來識別是串行隊列還是并發(fā)隊列。DISPATCH_QUEUE_SERIAL表示串行隊列，DISPATCH_QUEUE_CONCURRENT表示并發(fā)隊列。

// 串行隊列的創(chuàng)建方法 dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL); // 并發(fā)隊列的創(chuàng)建方法 dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT); 對于串行隊列，GCD 提供了的一種特殊的串行隊列：主隊列（Main Dispatch Queue）。所有放在主隊列中的任務(wù)，都會放到主線程中執(zhí)行。可使用dispatch_get_main_queue()獲得主隊列。

// 主隊列的獲取方法 dispatch_queue_t queue = dispatch_get_main_queue(); 對于并發(fā)隊列，GCD 默認(rèn)提供了全局并發(fā)隊列（Global Dispatch Queue）。可以使用dispatch_get_global_queue來獲取。需要傳入兩個參數(shù)。第一個參數(shù)表示隊列優(yōu)先級，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二個參數(shù)暫時沒用，用0即可。

// 全局并發(fā)隊列的獲取方法 dispatch_queue_t queue = 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ā)隊列來使用。但是主隊列因為有點特殊，所以我們就又多了兩種組合方式。這樣就有六種不同的組合方式了。

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

區(qū)別并發(fā)隊列串行隊列主隊列同步(sync) 沒有開啟新線程，串行執(zhí)行任務(wù) 沒有開啟新線程，串行執(zhí)行任務(wù) 主線程調(diào)用：死鎖卡住不執(zhí)行
其他線程調(diào)用：沒有開啟新線程，串行執(zhí)行任務(wù) 異步(async) 有開啟新線程，并發(fā)執(zhí)行任務(wù) 有開啟新線程(1條)，串行執(zhí)行任務(wù) 沒有開啟新線程，串行執(zhí)行任務(wù)

4.1 同步執(zhí)行并發(fā)隊列在當(dāng)前線程中執(zhí)行任務(wù)，不會開啟新線程，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

/** * 同步執(zhí)行并發(fā)隊列 * 特點：在當(dāng)前線程中執(zhí)行任務(wù)，不會開啟新線程，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。 */ – (void)syncConcurrent { NSLog(@"currentThread—%@",[NSThread currentThread]); // 打印當(dāng)前線程 NSLog(@"syncConcurrent—begin"); dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT); dispatch_sync(queue, ^{ // 追加任務(wù)1 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"1—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); dispatch_sync(queue, ^{ // 追加任務(wù)2 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"2—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); dispatch_sync(queue, ^{ // 追加任務(wù)3 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"3—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); 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

所有任務(wù)都是在當(dāng)前線程（主線程）中執(zhí)行的，沒有開啟新的線程（同步執(zhí)行不具備開啟新線程的能力）。所有任務(wù)都在打印的syncConcurrent—begin和syncConcurrent—end之間執(zhí)行的（同步任務(wù)需要等待隊列的任務(wù)執(zhí)行結(jié)束）。任務(wù)按順序執(zhí)行的。按順序執(zhí)行的原因：雖然并發(fā)隊列可以開啟多個線程，并且同時執(zhí)行多個任務(wù)。但是因為本身不能創(chuàng)建新線程，只有當(dāng)前線程這一個線程（同步任務(wù)不具備開啟新線程的能力），所以也就不存在并發(fā)。而且當(dāng)前線程只有等待當(dāng)前隊列中正在執(zhí)行的任務(wù)執(zhí)行完畢之后，才能繼續(xù)接著執(zhí)行下面的操作（同步任務(wù)需要等待隊列的任務(wù)執(zhí)行結(jié)束）。所以任務(wù)只能一個接一個按順序執(zhí)行，不能同時被執(zhí)行。 4.2 異步執(zhí)行并發(fā)隊列可以開啟多個線程，任務(wù)交替（同時）執(zhí)行。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

/** * 異步執(zhí)行并發(fā)隊列 * 特點：可以開啟多個線程，任務(wù)交替（同時）執(zhí)行。 */ – (void)asyncConcurrent { NSLog(@"currentThread—%@",[NSThread currentThread]); // 打印當(dāng)前線程 NSLog(@"asyncConcurrent—begin"); dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT); dispatch_async(queue, ^{ // 追加任務(wù)1 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"1—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); dispatch_async(queue, ^{ // 追加任務(wù)2 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"2—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); dispatch_async(queue, ^{ // 追加任務(wù)3 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"3—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); 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)}

除了當(dāng)前線程（主線程），系統(tǒng)又開啟了3個線程，并且任務(wù)是交替/同時執(zhí)行的。（異步執(zhí)行具備開啟新線程的能力。且并發(fā)隊列可開啟多個線程，同時執(zhí)行多個任務(wù)）。所有任務(wù)是在打印的syncConcurrent—begin和syncConcurrent—end之后才執(zhí)行的。說明當(dāng)前線程沒有等待，而是直接開啟了新線程，在新線程中執(zhí)行任務(wù)（異步執(zhí)行不做等待，可以繼續(xù)執(zhí)行任務(wù)）。

4.3 同步執(zhí)行串行隊列不會開啟新線程，在當(dāng)前線程執(zhí)行任務(wù)。任務(wù)是串行的，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

/** * 同步執(zhí)行串行隊列 * 特點：不會開啟新線程，在當(dāng)前線程執(zhí)行任務(wù)。任務(wù)是串行的，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。 */ – (void)syncSerial { NSLog(@"currentThread—%@",[NSThread currentThread]); // 打印當(dāng)前線程 NSLog(@"syncSerial—begin"); dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL); dispatch_sync(queue, ^{ // 追加任務(wù)1 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"1—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); dispatch_sync(queue, ^{ // 追加任務(wù)2 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"2—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); dispatch_sync(queue, ^{ // 追加任務(wù)3 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"3—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); 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

所有任務(wù)都是在當(dāng)前線程（主線程）中執(zhí)行的，并沒有開啟新的線程（同步執(zhí)行不具備開啟新線程的能力）。所有任務(wù)都在打印的syncConcurrent—begin和syncConcurrent—end之間執(zhí)行（同步任務(wù)需要等待隊列的任務(wù)執(zhí)行結(jié)束）。任務(wù)是按順序執(zhí)行的（串行隊列每次只有一個任務(wù)被執(zhí)行，任務(wù)一個接一個按順序執(zhí)行）。 4.4 異步執(zhí)行串行隊列會開啟新線程，但是因為任務(wù)是串行的，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

/** * 異步執(zhí)行串行隊列 * 特點：會開啟新線程，但是因為任務(wù)是串行的，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。 */ – (void)asyncSerial { NSLog(@"currentThread—%@",[NSThread currentThread]); // 打印當(dāng)前線程 NSLog(@"asyncSerial—begin"); dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL); dispatch_async(queue, ^{ // 追加任務(wù)1 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"1—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); dispatch_async(queue, ^{ // 追加任務(wù)2 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"2—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); dispatch_async(queue, ^{ // 追加任務(wù)3 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"3—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); 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í)行具備開啟新線程的能力，串行隊列只開啟一個線程）。所有任務(wù)是在打印的syncConcurrent—begin和syncConcurrent—end之后才開始執(zhí)行的（異步執(zhí)行不會做任何等待，可以繼續(xù)執(zhí)行任務(wù)）。任務(wù)是按順序執(zhí)行的（串行隊列每次只有一個任務(wù)被執(zhí)行，任務(wù)一個接一個按順序執(zhí)行）。

主隊列：GCD自帶的一種特殊的串行隊列所有放在主隊列中的任務(wù)，都會放到主線程中執(zhí)行可使用dispatch_get_main_queue()獲得主隊列

同步執(zhí)行主隊列在不同線程中調(diào)用結(jié)果也是不一樣，在主線程中調(diào)用會出現(xiàn)死鎖，而在其他線程中則不會。

4.5.1 在主線程中調(diào)用同步執(zhí)行主隊列互相等待卡住不可行

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

/** * 同步執(zhí)行主隊列 * 特點(主線程調(diào)用)：互等卡主不執(zhí)行。 * 特點(其他線程調(diào)用)：不會開啟新線程，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。 */ – (void)syncMain { NSLog(@"currentThread—%@",[NSThread currentThread]); // 打印當(dāng)前線程 NSLog(@"syncMain—begin"); dispatch_queue_t queue = dispatch_get_main_queue(); dispatch_sync(queue, ^{ // 追加任務(wù)1 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"1—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); dispatch_sync(queue, ^{ // 追加任務(wù)2 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"2—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); dispatch_sync(queue, ^{ // 追加任務(wù)3 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"3—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); 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í)行主隊列，追加到主線程的任務(wù)1、任務(wù)2、任務(wù)3都不再執(zhí)行了，而且syncMain—end也沒有打印，在XCode 9上還會報崩潰。這是為什么呢？

這是因為我們在主線程中執(zhí)行syncMain方法，相當(dāng)于把syncMain任務(wù)放到了主線程的隊列中。而同步執(zhí)行會等待當(dāng)前隊列中的任務(wù)執(zhí)行完畢，才會接著執(zhí)行。那么當(dāng)我們把任務(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:self withObject: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

所有任務(wù)都是在主線程（非當(dāng)前線程）中執(zhí)行的，沒有開啟新的線程（所有放在主隊列中的任務(wù)，都會放到主線程中執(zhí)行）。所有任務(wù)都在打印的syncConcurrent—begin和syncConcurrent—end之間執(zhí)行（同步任務(wù)需要等待隊列的任務(wù)執(zhí)行結(jié)束）。任務(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ù)。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

/** * 異步執(zhí)行主隊列 * 特點：只在主線程中執(zhí)行任務(wù)，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù) */ – (void)asyncMain { NSLog(@"currentThread—%@",[NSThread currentThread]); // 打印當(dāng)前線程 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]); // 打印當(dāng)前線程 } }); dispatch_async(queue, ^{ // 追加任務(wù)2 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"2—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); dispatch_async(queue, ^{ // 追加任務(wù)3 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"3—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); 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}

所有任務(wù)都是在當(dāng)前線程（主線程）中執(zhí)行的，并沒有開啟新的線程（雖然異步執(zhí)行具備開啟線程的能力，但因為是主隊列，所以所有任務(wù)都在主線程中）。所有任務(wù)是在打印的syncConcurrent—begin和syncConcurrent—end之后才開始執(zhí)行的（異步執(zhí)行不會做任何等待，可以繼續(xù)執(zhí)行任務(wù)）。任務(wù)是按順序執(zhí)行的（因為主隊列是串行隊列，每次只有一個任務(wù)被執(zhí)行，任務(wù)一個接一個按順序執(zhí)行）。

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

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

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

輸出結(jié)果：
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}

可以看到在其他線程中先執(zhí)行任務(wù)，執(zhí)行完了之后回到主線程執(zhí)行主線程的相應(yīng)操作。 6. GCD 的其他方法 6.1 GCD 柵欄方法：dispatch_barrier_async 我們有時需要異步執(zhí)行兩組操作，而且第一組操作執(zhí)行完之后，才能開始執(zhí)行第二組操作。這樣我們就需要一個相當(dāng)于柵欄一樣的一個方法將兩組異步執(zhí)行的操作組給分割起來，當(dāng)然這里的操作組里可以包含一個或多個任務(wù)。這就需要用到dispatch_barrier_async方法在兩個操作組間形成柵欄。
dispatch_barrier_async函數(shù)會等待前邊追加到并發(fā)隊列中的任務(wù)全部執(zhí)行完畢之后，再將指定的任務(wù)追加到該異步隊列中。然后在dispatch_barrier_async函數(shù)追加的任務(wù)執(zhí)行完畢之后，異步隊列才恢復(fù)為一般動作，接著追加任務(wù)到該異步隊列并開始執(zhí)行。具體如下圖所示：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

/** * 柵欄方法 dispatch_barrier_async */ – (void)barrier { dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT); dispatch_async(queue, ^{ // 追加任務(wù)1 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"1—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); dispatch_async(queue, ^{ // 追加任務(wù)2 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"2—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); dispatch_barrier_async(queue, ^{ // 追加任務(wù) barrier for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"barrier—%@",[NSThread currentThread]);// 打印當(dāng)前線程 } }); dispatch_async(queue, ^{ // 追加任務(wù)3 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"3—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); dispatch_async(queue, ^{ // 追加任務(wù)4 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"4—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); }

輸出結(jié)果：
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)}

在執(zhí)行完柵欄前面的操作之后，才執(zhí)行柵欄操作，最后再執(zhí)行柵欄后邊的操作。 6.2 GCD 延時執(zhí)行方法：dispatch_after

我們經(jīng)常會遇到這樣的需求：在指定時間（例如3秒）之后執(zhí)行某個任務(wù)。可以用 GCD 的dispatch_after函數(shù)來實現(xiàn)。
需要注意的是：dispatch_after函數(shù)并不是在指定時間之后才開始執(zhí)行處理，而是在指定時間之后將任務(wù)追加到主隊列中。嚴(yán)格來說，這個時間并不是絕對準(zhǔn)確的，但想要大致延遲執(zhí)行任務(wù)，dispatch_after函數(shù)是很有效的。

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

輸出結(jié)果：
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—<NSThread: 0x60000006ee00>{number = 1, name = main}

6.3 GCD 一次性代碼（只執(zhí)行一次）：dispatch_once 我們在創(chuàng)建單例、或者有整個程序運行過程中只執(zhí)行一次的代碼時，我們就用到了 GCD 的dispatch_once函數(shù)。使用
dispatch_once函數(shù)能保證某段代碼在程序運行過程中只被執(zhí)行1次，并且即使在多線程的環(huán)境下，dispatch_once也可以保證線程安全。

/** * 一次性代碼（只執(zhí)行一次）dispatch_once */ – (void)once { static dispatch_once_t onceToken; dispatch_once(&onceToken, ^{ // 只執(zhí)行1次的代碼(這里面默認(rèn)是線程安全的) }); } 6.4 GCD 快速迭代方法：dispatch_apply 通常我們會用 for 循環(huán)遍歷，但是 GCD 給我們提供了快速迭代的函數(shù)dispatch_apply。dispatch_apply按照指定的次數(shù)將指定的任務(wù)追加到指定的隊列中，并等待全部隊列執(zhí)行結(jié)束。

如果是在串行隊列中使用dispatch_apply，那么就和 for 循環(huán)一樣，按順序同步執(zhí)行。可這樣就體現(xiàn)不出快速迭代的意義了。
我們可以利用并發(fā)隊列進行異步執(zhí)行。比如說遍歷 0~5 這6個數(shù)字，for 循環(huán)的做法是每次取出一個元素，逐個遍歷。dispatch_apply可以在多個線程中同時（異步）遍歷多個數(shù)字。
還有一點，無論是在串行隊列，還是異步隊列中，dispatch_apply 都會等待全部任務(wù)執(zhí)行完畢，這點就像是同步操作，也像是隊列組中的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"); }

輸出結(jié)果：
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

因為是在并發(fā)隊列中異步隊執(zhí)行任務(wù)，所以各個任務(wù)的執(zhí)行時間長短不定，最后結(jié)束順序也不定。但是apply—end一定在最后執(zhí)行。這是因為dispatch_apply函數(shù)會等待全部任務(wù)執(zhí)行完畢。

有時候我們會有這樣的需求：分別異步執(zhí)行2個耗時任務(wù)，然后當(dāng)2個耗時任務(wù)都執(zhí)行完畢后再回到主線程執(zhí)行任務(wù)。這時候我們可以用到 GCD 的隊列組。

調(diào)用隊列組的dispatch_group_async先把任務(wù)放到隊列中，然后將隊列放入隊列組中。或者使用隊列組的dispatch_group_enter、dispatch_group_leave組合來實現(xiàn)
dispatch_group_async。調(diào)用隊列組的dispatch_group_notify回到指定線程執(zhí)行任務(wù)。或者使用dispatch_group_wait回到當(dāng)前線程繼續(xù)向下執(zhí)行（會阻塞當(dāng)前線程）。 6.5.1 dispatch_group_notify 監(jiān)聽 group 中任務(wù)的完成狀態(tài)，當(dāng)所有的任務(wù)都執(zhí)行完成后，追加任務(wù)到 group 中，并執(zhí)行任務(wù)。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

/** * 隊列組 dispatch_group_notify */ – (void)groupNotify { NSLog(@"currentThread—%@",[NSThread currentThread]); // 打印當(dāng)前線程 NSLog(@"group—begin"); dispatch_group_t group = dispatch_group_create(); dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ // 追加任務(wù)1 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"1—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ // 追加任務(wù)2 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"2—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); dispatch_group_notify(group, dispatch_get_main_queue(), ^{ // 等前面的異步任務(wù)1、任務(wù)2都執(zhí)行完畢后，回到主線程執(zhí)行下邊任務(wù) for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"3—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } NSLog(@"group—end"); }); }

輸出結(jié)果：
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相關(guān)代碼運行輸出結(jié)果可以看出：
當(dāng)所有任務(wù)都執(zhí)行完成之后，才執(zhí)行dispatch_group_notifyblock 中的任務(wù)。

6.5.2 dispatch_group_wait 暫停當(dāng)前線程（阻塞當(dāng)前線程），等待指定的 group 中的任務(wù)執(zhí)行完成后，才會往下繼續(xù)執(zhí)行。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

/** * 隊列組 dispatch_group_wait */ – (void)groupWait { NSLog(@"currentThread—%@",[NSThread currentThread]); // 打印當(dāng)前線程 NSLog(@"group—begin"); dispatch_group_t group = dispatch_group_create(); dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ // 追加任務(wù)1 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"1—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ // 追加任務(wù)2 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"2—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } }); // 等待上面的任務(wù)全部完成后，會往下繼續(xù)執(zhí)行（會阻塞當(dāng)前線程） dispatch_group_wait(group, DISPATCH_TIME_FOREVER); NSLog(@"group—end"); }

輸出結(jié)果：
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相關(guān)代碼運行輸出結(jié)果可以看出：
當(dāng)所有任務(wù)執(zhí)行完成之后，才執(zhí)行dispatch_group_wait之后的操作。但是，使用dispatch_group_wait會阻塞當(dāng)前線程。

6.5.3 dispatch_group_enter、dispatch_group_leave dispatch_group_enter標(biāo)志著一個任務(wù)追加到 group，執(zhí)行一次，相當(dāng)于 group 中未執(zhí)行完畢任務(wù)數(shù) 1 dispatch_group_leave標(biāo)志著一個任務(wù)離開了 group，執(zhí)行一次，相當(dāng)于 group 中未執(zhí)行完畢任務(wù)數(shù)-1。當(dāng) group 中未執(zhí)行完畢任務(wù)數(shù)為0的時候，才會使dispatch_group_wait解除阻塞，以及執(zhí)行追加到dispatch_group_notify中的任務(wù)。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

/** * 隊列組 dispatch_group_enter、dispatch_group_leave */ – (void)groupEnterAndLeave { NSLog(@"currentThread—%@",[NSThread currentThread]); // 打印當(dāng)前線程 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, ^{ // 追加任務(wù)1 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"1—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } dispatch_group_leave(group); }); dispatch_group_enter(group); dispatch_async(queue, ^{ // 追加任務(wù)2 for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"2—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } dispatch_group_leave(group); }); dispatch_group_notify(group, dispatch_get_main_queue(), ^{ // 等前面的異步操作都執(zhí)行完畢后，回到主線程. for (int i = 0; i < 2; i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"3—%@",[NSThread currentThread]); // 打印當(dāng)前線程 } NSLog(@"group—end"); }); // // 等待上面的任務(wù)全部完成后，會往下繼續(xù)執(zhí)行（會阻塞當(dāng)前線程） // dispatch_group_wait(group, DISPATCH_TIME_FOREVER); // // NSLog(@"group—end"); }

輸出結(jié)果：
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相關(guān)代碼運行結(jié)果中可以看出：當(dāng)所有任務(wù)執(zhí)行完成之后，才執(zhí)行 dispatch_group_notify 中的任務(wù)。這里的dispatch_group_enter、dispatch_group_leave組合，其實等同于dispatch_group_async。

GCD 中的信號量是指Dispatch Semaphore，是持有計數(shù)的信號。類似于過高速路收費站的欄桿。可以通過時，打開欄桿，不可以通過時，關(guān)閉欄桿。在Dispatch Semaphore中，使用計數(shù)來完成這個功能，計數(shù)為0時等待，不可通過。計數(shù)為1或大于1時，計數(shù)減1且不等待，可通過。
Dispatch Semaphore提供了三個函數(shù)。

dispatch_semaphore_create：創(chuàng)建一個Semaphore并初始化信號的總量 dispatch_semaphore_signal：發(fā)送一個信號，讓信號總量加1 dispatch_semaphore_wait：可以使總信號量減1，當(dāng)信號總量為0時就會一直等待（阻塞所在線程），否則就可以正常執(zhí)行。

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

保持線程同步，將異步執(zhí)行任務(wù)轉(zhuǎn)換為同步執(zhí)行任務(wù) 保證線程安全，為線程加鎖 6.6.1 Dispatch Semaphore 線程同步

我們在開發(fā)中，會遇到這樣的需求：異步執(zhí)行耗時任務(wù)，并使用異步執(zhí)行的結(jié)果進行一些額外的操作。換句話說，相當(dāng)于，將將異步執(zhí)行任務(wù)轉(zhuǎn)換為同步執(zhí)行任務(wù)。比如說：AFNetworking 中 AFURLSessionManager.m 里面的tasksForKeyPath:方法。通過引入信號量的方式，等待異步執(zhí)行任務(wù)結(jié)果，獲取到 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 實現(xiàn)線程同步，將異步執(zhí)行任務(wù)轉(zhuǎn)換為同步執(zhí)行任務(wù)。

/** * semaphore 線程同步 */ – (void)semaphoreSync { NSLog(@"currentThread—%@",[NSThread currentThread]); // 打印當(dāng)前線程 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, ^{ // 追加任務(wù)1 [NSThread sleepForTimeInterval:2]; // 模擬耗時操作 NSLog(@"1—%@",[NSThread currentThread]); // 打印當(dāng)前線程 number = 100; dispatch_semaphore_signal(semaphore); }); dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER); NSLog(@"semaphore—end,number = %zd",number); }

輸出結(jié)果：
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

semaphore—end是在執(zhí)行完number = 100;之后才打印的。而且輸出結(jié)果 number 為 100。
這是因為異步執(zhí)行不會做任何等待，可以繼續(xù)執(zhí)行任務(wù)。異步執(zhí)行將任務(wù)1追加到隊列之后，不做等待，接著執(zhí)行dispatch_semaphore_wait方法。此時 semaphore == 0，當(dāng)前線程進入等待狀態(tài)。然后，異步任務(wù)1開始執(zhí)行。任務(wù)1執(zhí)行到dispatch_semaphore_signal之后，總信號量，此時 semaphore == 1，dispatch_semaphore_wait方法使總信號量減1，正在被阻塞的線程（主線程）恢復(fù)繼續(xù)執(zhí)行。最后打印semaphore—end,number = 100。這樣就實現(xiàn)了線程同步，將異步執(zhí)行任務(wù)轉(zhuǎn)換為同步執(zhí)行任務(wù)。 6.6.2 Dispatch Semaphore 線程安全和線程同步（為線程加鎖）

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

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

線程同步：可理解為線程 A 和線程 B 一塊配合，A 執(zhí)行到一定程度時要依靠線程 B 的某個結(jié)果，于是停下來，示意 B 運行；B 依言執(zhí)行，再將結(jié)果給 A；A 再繼續(xù)操作。

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

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

/** * 非線程安全：不使用 semaphore * 初始化火車票數(shù)量、賣票窗口(非線程安全)、并開始賣票 */ – (void)initTicketStatusNotSave { NSLog(@"currentThread—%@",[NSThread currentThread]); // 打印當(dāng)前線程 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) { //如果還有票，繼續(xù)售賣 self.ticketSurplusCount–; NSLog(@"%@", [NSString stringWithFormat:@"剩余票數(shù)：%d 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]); [NSThread sleepForTimeInterval:0.2]; } else { //如果已賣完，關(guān)閉售票窗口 NSLog(@"所有火車票均已售完"); break; } } }

輸出結(jié)果（部分）：
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] 剩余票數(shù)：48 窗口：{number = 3, name = (null)}
2018-02-23 22:25:35.789646 0800 YSC-GCD-demo[20712:5259175] 剩余票數(shù)：49 窗口：{number = 4, name = (null)}
2018-02-23 22:25:35.994113 0800 YSC-GCD-demo[20712:5259175] 剩余票數(shù)：47 窗口：{number = 4, name = (null)}
2018-02-23 22:25:35.994129 0800 YSC-GCD-demo[20712:5259176] 剩余票數(shù)：46 窗口：{number = 3, name = (null)}
2018-02-23 22:25:36.198993 0800 YSC-GCD-demo[20712:5259176] 剩余票數(shù)：45 窗口：{number = 3, name = (null)}
…

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

/** * 線程安全：使用 semaphore 加鎖 * 初始化火車票數(shù)量、賣票窗口(線程安全)、并開始賣票 */ – (void)initTicketStatusSave { NSLog(@"currentThread—%@",[NSThread currentThread]); // 打印當(dāng)前線程 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) { // 相當(dāng)于加鎖 dispatch_semaphore_wait(semaphoreLock, DISPATCH_TIME_FOREVER); if (self.ticketSurplusCount > 0) { //如果還有票，繼續(xù)售賣 self.ticketSurplusCount–; NSLog(@"%@", [NSString stringWithFormat:@"剩余票數(shù)：%d 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]); [NSThread sleepForTimeInterval:0.2]; } else { //如果已賣完，關(guān)閉售票窗口 NSLog(@"所有火車票均已售完"); // 相當(dāng)于解鎖 dispatch_semaphore_signal(semaphoreLock); break; } // 相當(dāng)于解鎖 dispatch_semaphore_signal(semaphoreLock); } }

輸出結(jié)果為：
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] 剩余票數(shù)：49 窗口：{number = 3, name = (null)}
2018-02-23 22:32:20.017745 0800 YSC-GCD-demo[20862:5290689] 剩余票數(shù)：48 窗口：{number = 4, name = (null)}
2018-02-23 22:32:20.222039 0800 YSC-GCD-demo[20862:5290687] 剩余票數(shù)：47 窗口：{number = 3, name = (null)}
…
2018-02-23 22:32:29.024817 0800 YSC-GCD-demo[20862:5290689] 剩余票數(shù)：4 窗口：{number = 4, name = (null)}
2018-02-23 22:32:29.230110 0800 YSC-GCD-demo[20862:5290687] 剩余票數(shù)：3 窗口：{number = 3, name = (null)}
2018-02-23 22:32:29.433615 0800 YSC-GCD-demo[20862:5290689] 剩余票數(shù)：2 窗口：{number = 4, name = (null)}
2018-02-23 22:32:29.637572 0800 YSC-GCD-demo[20862:5290687] 剩余票數(shù)：1 窗口：{number = 3, name = (null)}
2018-02-23 22:32:29.840234 0800 YSC-GCD-demo[20862:5290689] 剩余票數(shù)：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
機制之后，得到的票數(shù)是正確的，沒有出現(xiàn)混亂的情況。我們也就解決了多個線程同步的問題。

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以原創(chuàng)、轉(zhuǎn)載和分享網(wǎng)絡(luò)內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。郵箱：3140448839@qq.com。本站原創(chuàng)內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時需注明出處：三五互聯(lián)知識庫 » GCD

熱門搶注

熱門競價

推薦一口價

猜你還會喜歡下面的內(nèi)容

熱門標(biāo)簽

切換注冊登錄

切換登錄注冊