GCD 簡介
GCD 任務(wù)和隊列
GCD 的使用步驟
GCD 的基本使用（六種組合不同區(qū)別，隊列嵌套情況區(qū)別，相互關(guān)系形象理解）
GCD 線程間的通信
GCD 的其他方法（柵欄方法：dispatch_barrier_async、延時執(zhí)行方法：dispatch_after、一次性代碼（只執(zhí)行一次）：dispatch_once、快速迭代方法：dispatch_apply、隊列組：dispatch_group、信號量：dispatch_semaphore）

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

2. GCD 任務(wù)和隊列

任務(wù)：就是執(zhí)行操作的意思，換句話說就是你在線程中執(zhí)行的那段代碼。在 GCD 中是放在 block 中的。執(zhí)行任務(wù)有兩種方式：『同步執(zhí)行』和『異步執(zhí)行』。兩者的主要區(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é)束（不用等待任務(wù)執(zhí)行結(jié)束），還能同時給小白打電話。而且除了當(dāng)前電話，你還可以使用其他一個或多個電話（具備開啟新線程的能力）。

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

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

隊列（Dispatch Queue）.png

在 GCD 中有兩種隊列：『串行隊列』和『并發(fā)隊列』。兩者都符合 FIFO（先進(jìn)先出）的原則。兩者的主要區(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）方法下才有效。

兩者具體區(qū)別如下兩圖所示：

串行隊列（Serial Dispatch Queue）.png

并發(fā)隊列（Concurrent Dispatch Queue）.png

3. GCD 的使用步驟

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

1.創(chuàng)建一個隊列（串行隊列或并發(fā)隊列）；
將任務(wù)追加到任務(wù)的等待隊列中，然后系統(tǒng)就會根據(jù)
2.任務(wù)類型執(zhí)行任務(wù)（同步執(zhí)行或異步執(zhí)行）。
下邊來看看隊列的創(chuàng)建方法 / 獲取方法，以及任務(wù)的創(chuàng)建方法。

3.1 隊列的創(chuàng)建方法 / 獲取方法

可以使用 dispatch_queue_create 方法來創(chuàng)建隊列。該方法需要傳入兩個參數(shù)：
- 第一個參數(shù)表示隊列的唯一標(biāo)識符，用于 DEBUG，可為空。隊列的名稱推薦使用應(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 默認(rèn)提供了：『主隊列（Main Dispatch Queue）』。
- 所有放在主隊列中的任務(wù)，都會放到主線程中執(zhí)行。
- 可使用 dispatch_get_main_queue() 方法獲得主隊列。

注意：主隊列其實(shí)并不特殊。主隊列的實(shí)質(zhì)上就是一個普通的串行隊列，只是因?yàn)槟J(rèn)情況下，當(dāng)前代碼是放在主隊列中的，然后主隊列中的代碼，有都會放到主線程中去執(zhí)行，所以才造成了主隊列特殊的現(xiàn)象。

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

對于并發(fā)隊列，GCD 默認(rèn)提供了『全局并發(fā)隊列（Global Dispatch Queue）』。
- 可以使用 dispatch_get_global_queue 方法來獲取全局并發(fā)隊列。需要傳入兩個參數(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í)行 + 串行隊列

實(shí)際上，剛才還說了兩種默認(rèn)隊列：全局并發(fā)隊列、主隊列。全局并發(fā)隊列可以作為普通并發(fā)隊列來使用。但是當(dāng)前代碼默認(rèn)放在主隊列中，所以主隊列很有必要專門來研究一下，所以我們就又多了兩種組合方式。這樣就有六種不同的組合方式了。

同步執(zhí)行 + 主隊列
異步執(zhí)行 + 主隊列

那么這幾種不同組合方式各有什么區(qū)別呢？

這里我們先上結(jié)論，后面再來詳細(xì)講解。你可以直接查看 3.3 任務(wù)和隊列不同組合方式的區(qū)別中的表格結(jié)果，然后跳過 4. GCD的基本使用繼續(xù)往后看。

3.3 任務(wù)和隊列不同組合方式的區(qū)別

我們先來考慮最基本的使用，也就是當(dāng)前線程為『主線程』的環(huán)境下，『不同隊列』+『不同任務(wù)』簡單組合使用的不同區(qū)別。暫時不考慮『隊列中嵌套隊列』的這種復(fù)雜情況。

『主線程』中，『不同隊列』+『不同任務(wù)』簡單組合的區(qū)別：

image.png

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

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

除了上邊提到的『主線程』中調(diào)用『主隊列』+『同步執(zhí)行』會導(dǎo)致死鎖問題。實(shí)際在使用『串行隊列』的時候，也可能出現(xiàn)阻塞『串行隊列』所在線程的情況發(fā)生，從而造成死鎖問題。這種情況多見于同一個串行隊列的嵌套使用。

比如下面代碼這樣：在『異步執(zhí)行』+『串行隊列』的任務(wù)中，又嵌套了『當(dāng)前的串行隊列』，然后進(jìn)行『同步執(zhí)行』。

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

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

主隊列造成死鎖也是基于這個原因，所以，這也進(jìn)一步說明了主隊列其實(shí)并不特殊。

關(guān)于『隊列中嵌套隊列』這種復(fù)雜情況，這里也簡單做一個總結(jié)。不過這里只考慮同一個隊列的嵌套情況，關(guān)于多個隊列的相互嵌套情況還請自行研究，或者等我最新的文章發(fā)布。

『不同隊列』+『不同任務(wù)』組合，以及『隊列中嵌套隊列』使用的區(qū)別：

image.png

3.5 關(guān)于不同隊列和不同任務(wù)的形象理解

因?yàn)榍耙欢螘r間看到了有朋友留言說對異步執(zhí)行和并發(fā)隊列中創(chuàng)建線程能力有所不理解，我覺得這個問題的確很容易造成困惑，所以很值得拿來專門分析一下。

他的問題：
在異步 + 并發(fā) 中的解釋：
（異步執(zhí)行具備開啟新線程的能力。且并發(fā)隊列可開啟多個線程，同時執(zhí)行多個任務(wù)）
以及同步 + 并發(fā) 中的解釋：
（雖然并發(fā)隊列可以開啟多個線程，并且同時執(zhí)行多個任務(wù)。但是因?yàn)楸旧聿荒軇?chuàng)建新線程，只有當(dāng)前線程這一個線程（同步任務(wù)不具備開啟新線程的能力）
這個地方看起來有點(diǎn)疑惑，你兩個地方分別提到：異步執(zhí)行開啟新線程，并發(fā)隊列也可以開啟新線程，想請教下，你的意思是只有任務(wù)才擁有創(chuàng)建新線程的能力，而隊列只有開啟線程的能力，并不能創(chuàng)建線程？這二者是這樣的關(guān)聯(lián)嗎？

關(guān)于這個問題，我想做一個很形象的類比，來幫助大家對隊列、任務(wù) 以及線程之間關(guān)系的理解。

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

這個故事里，人好比是任務(wù)，管理員好比是系統(tǒng)，入口則代表線程。

5 個人表示有 5 個任務(wù)，10 個入口代表 10 條線程。

串行隊列好比是 5 個人排成一支長隊。

并發(fā)隊列好比是 5 個人排成多支隊伍，比如 2 隊，或者 3 隊。

同步任務(wù) 好比是管理員只開啟了一個入口（當(dāng)前線程）。

異步任務(wù) 好比是管理員同時開啟了多個入口（當(dāng)前線程 + 新開的線程）。

『異步執(zhí)行 + 并發(fā)隊列』可以理解為：現(xiàn)在管理員開啟了多個入口（比如 3 個入口），5 個人排成了多支隊伍（比如 3 支隊伍），這樣這 5 個人就可以 3 個人同時一起穿過門禁了。

『同步執(zhí)行 + 并發(fā)隊列』可以理解為：現(xiàn)在管理員只開啟了 1 個入口，5 個人排成了多支隊伍。雖然這 5 個人排成了多支隊伍，但是只開了 1 個入口啊，這 5 個人雖然都想快點(diǎn)過去，但是 1 個入口一次只能過 1 個人，所以大家就只好一個接一個走過去了，表現(xiàn)的結(jié)果就是：順次通過入口。

換成 GCD 里的語言就是說：

『異步執(zhí)行 + 并發(fā)隊列』就是：系統(tǒng)開啟了多個線程（主線程+其他子線程），任務(wù)可以多個同時運(yùn)行。

『同步執(zhí)行 + 并發(fā)隊列』就是：系統(tǒng)只默認(rèn)開啟了一個主線程，沒有開啟子線程，雖然任務(wù)處于并發(fā)隊列中，但也只能一個接一個執(zhí)行了。

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

4. GCD 的基本使用

先來講講并發(fā)隊列的兩種執(zhí)行方式。

4.1 同步執(zhí)行 + 并發(fā)隊列

在當(dāng)前線程中執(zhí)行任務(wù)，不會開啟新線程，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。

/**
 * 同步執(zhí)行 + 并發(fā)隊列
 * 特點(diǎn)：在當(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
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
    });
    
    dispatch_sync(queue, ^{
        // 追加任務(wù) 2
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
    });
    
    dispatch_sync(queue, ^{
        // 追加任務(wù) 3
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
    });
    
    NSLog(@"syncConcurrent---end");
}
2020-03-02 17:31:34.157409+0800 GCDDemo[34809:1841888] currentThread---<NSThread: 0x600001ed0640>{number = 1, name = main}
2020-03-02 17:31:34.157574+0800 GCDDemo[34809:1841888] syncConcurrent---begin
2020-03-02 17:31:36.157857+0800 GCDDemo[34809:1841888] 1---<NSThread: 0x600001ed0640>{number = 1, name = main}
2020-03-02 17:31:38.159373+0800 GCDDemo[34809:1841888] 2---<NSThread: 0x600001ed0640>{number = 1, name = main}
2020-03-02 17:31:40.160453+0800 GCDDemo[34809:1841888] 3---<NSThread: 0x600001ed0640>{number = 1, name = main}
2020-03-02 17:31:40.160794+0800 GCDDemo[34809:1841888] syncConcurrent---end

從同步執(zhí)行 + 并發(fā)隊列中可看到：

所有任務(wù)都是在當(dāng)前線程（主線程）中執(zhí)行的，沒有開啟新的線程（同步執(zhí)行不具備開啟新線程的能力）。
所有任務(wù)都在打印的 syncConcurrent---begin 和 syncConcurrent---end 之間執(zhí)行的（同步任務(wù) 需要等待隊列的任務(wù)執(zhí)行結(jié)束）。
任務(wù)按順序執(zhí)行的。按順序執(zhí)行的原因：雖然并發(fā)隊列可以開啟多個線程，并且同時執(zhí)行多個任務(wù)。但是因?yàn)楸旧聿荒軇?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í)行。

/**
 * 異步執(zhí)行 + 并發(fā)隊列
 * 特點(diǎn)：可以開啟多個線程，任務(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
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
    });
    
    dispatch_async(queue, ^{
        // 追加任務(wù) 2
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
    });
    
    dispatch_async(queue, ^{
        // 追加任務(wù) 3
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
    });
    
    NSLog(@"asyncConcurrent---end");
}
020-03-02 17:45:47.341372+0800 GCDDemo[34881:1850595] currentThread---<NSThread: 0x600000816dc0>{number = 1, name = main}
2020-03-02 17:45:47.341533+0800 GCDDemo[34881:1850595] asyncConcurrent---begin
2020-03-02 17:45:47.341665+0800 GCDDemo[34881:1850595] asyncConcurrent---end
2020-03-02 17:45:49.344790+0800 GCDDemo[34881:1851049] 1---<NSThread: 0x60000086d300>{number = 6, name = (null)}
2020-03-02 17:45:49.344790+0800 GCDDemo[34881:1851048] 2---<NSThread: 0x600000871900>{number = 3, name = (null)}
2020-03-02 17:45:49.344790+0800 GCDDemo[34881:1851053] 3---<NSThread: 0x60000086aac0>{number = 7, name = (null)}

在異步執(zhí)行 + 并發(fā)隊列中可以看出：

除了當(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ù)）。

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

4.3 同步執(zhí)行 + 串行隊列

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

/**
 * 同步執(zhí)行 + 串行隊列
 * 特點(diǎn)：不會開啟新線程，在當(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
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
    });
    dispatch_sync(queue, ^{
        // 追加任務(wù) 2
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
    });
    dispatch_sync(queue, ^{
        // 追加任務(wù) 3
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
    });
    
    NSLog(@"syncSerial---end");
}
2020-03-02 17:48:38.060067+0800 GCDDemo[34898:1853172] currentThread---<NSThread: 0x6000029ad380>{number = 1, name = main}
2020-03-02 17:48:38.060265+0800 GCDDemo[34898:1853172] syncSerial---begin
2020-03-02 17:48:40.061286+0800 GCDDemo[34898:1853172] 1---<NSThread: 0x6000029ad380>{number = 1, name = main}
2020-03-02 17:48:42.062525+0800 GCDDemo[34898:1853172] 2---<NSThread: 0x6000029ad380>{number = 1, name = main}
2020-03-02 17:48:44.063859+0800 GCDDemo[34898:1853172] 3---<NSThread: 0x6000029ad380>{number = 1, name = main}
2020-03-02 17:48:44.064135+0800 GCDDemo[34898:1853172] syncSerial---end

在同步執(zhí)行 + 串行隊列可以看到：

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

4.4 異步執(zhí)行 + 串行隊列

會開啟新線程，但是因?yàn)槿蝿?wù)是串行的，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)

/**
 * 異步執(zhí)行 + 串行隊列
 * 特點(diǎn)：會開啟新線程，但是因?yàn)槿蝿?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
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
    });
    dispatch_async(queue, ^{
        // 追加任務(wù) 2
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
    });
    dispatch_async(queue, ^{
        // 追加任務(wù) 3
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
    });
    
    NSLog(@"asyncSerial---end");
}
2020-03-02 17:50:11.021568+0800 GCDDemo[34912:1854945] currentThread---<NSThread: 0x600000716d00>{number = 1, name = main}
2020-03-02 17:50:11.021737+0800 GCDDemo[34912:1854945] asyncSerial---begin
2020-03-02 17:50:11.021866+0800 GCDDemo[34912:1854945] asyncSerial---end
2020-03-02 17:50:13.025225+0800 GCDDemo[34912:1855380] 1---<NSThread: 0x600000749240>{number = 3, name = (null)}
2020-03-02 17:50:15.028006+0800 GCDDemo[34912:1855380] 2---<NSThread: 0x600000749240>{number = 3, name = (null)}
2020-03-02 17:50:17.030770+0800 GCDDemo[34912:1855380] 3---<NSThread: 0x600000749240>{number = 3, name = (null)}

在異步執(zhí)行 + 串行隊列可以看到：

開啟了一條新線程（異步執(zhí)行具備開啟新線程的能力，串行隊列只開啟一個線程）。
所有任務(wù)是在打印的 syncConcurrent---begin 和 syncConcurrent---end 之后才開始執(zhí)行的（異步執(zhí)行不會做任何等待，可以繼續(xù)執(zhí)行任務(wù)）。
任務(wù)是按順序執(zhí)行的（串行隊列每次只有一個任務(wù)被執(zhí)行，任務(wù)一個接一個按順序執(zhí)行）。
下邊講講剛才我們提到過的：主隊列。
主隊列：GCD 默認(rèn)提供的串行隊列。
- 默認(rèn)情況下，平常所寫代碼是直接放在主隊列中的。
- 所有放在主隊列中的任務(wù)，都會放到主線程中執(zhí)行。
- 可使用 dispatch_get_main_queue() 獲得主隊列

4.5 同步執(zhí)行 + 主隊列

同步執(zhí)行 + 主隊列在不同線程中調(diào)用結(jié)果也是不一樣，在主線程中調(diào)用會發(fā)生死鎖問題，而在其他線程中調(diào)用則不會。

4.5.1 在主線程中調(diào)用『同步執(zhí)行 + 主隊列』

互相等待卡住不可行

/**
 * 同步執(zhí)行 + 主隊列
 * 特點(diǎn)(主線程調(diào)用)：互等卡主不執(zhí)行。
 * 特點(diǎn)(其他線程調(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
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
    });
    
    dispatch_sync(queue, ^{
        // 追加任務(wù) 2
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
    });
    
    dispatch_sync(queue, ^{
        // 追加任務(wù) 3
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
    });
    
    NSLog(@"syncMain---end");
}

在主線程中使用同步執(zhí)行 + 主隊列可以驚奇的發(fā)現(xiàn)：

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

這是因?yàn)槲覀冊谥骶€程中執(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];

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

所有任務(wù)都是在主線程（非當(dāng)前線程）中執(zhí)行的，沒有開啟新的線程（所有放在主隊列中的任務(wù)，都會放到主線程中執(zhí)行）。
所有任務(wù)都在打印的 syncConcurrent---begin 和 syncConcurrent---end 之間執(zhí)行（同步任務(wù) 需要等待隊列的任務(wù)執(zhí)行結(jié)束）。
任務(wù)是按順序執(zhí)行的（主隊列是串行隊列，每次只有一個任務(wù)被執(zhí)行，任務(wù)一個接一個按順序執(zhí)行）。
為什么現(xiàn)在就不會卡住了呢？

因?yàn)閟yncMain 任務(wù) 放到了其他線程里，而任務(wù) 1、任務(wù) 2、任務(wù)3 都在追加到主隊列中，這三個任務(wù)都會在主線程中執(zhí)行。syncMain 任務(wù) 在其他線程中執(zhí)行到追加任務(wù) 1 到主隊列中，因?yàn)橹麝犃鞋F(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í)行 + 主隊列
 * 特點(diǎn)：只在主線程中執(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
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
    });
    
    dispatch_async(queue, ^{
        // 追加任務(wù) 2
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
    });
    
    dispatch_async(queue, ^{
        // 追加任務(wù) 3
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
    });
    
    NSLog(@"asyncMain---end");
}

在異步執(zhí)行 + 主隊列可以看到：

所有任務(wù)都是在當(dāng)前線程（主線程）中執(zhí)行的，并沒有開啟新的線程（雖然異步執(zhí)行具備開啟線程的能力，但因?yàn)槭侵麝犃校运腥蝿?wù)都在主線程中）。
所有任務(wù)是在打印的 syncConcurrent---begin 和 syncConcurrent---end 之后才開始執(zhí)行的（異步執(zhí)行不會做任何等待，可以繼續(xù)執(zhí)行任務(wù)）。
任務(wù)是按順序執(zhí)行的（因?yàn)橹麝犃惺?串行隊列，每次只有一個任務(wù)被執(zhí)行，任務(wù)一個接一個按順序執(zhí)行）。

5. GCD 線程間的通信

在 iOS 開發(fā)過程中，我們一般在主線程里邊進(jìn)行 UI 刷新，例如：點(diǎn)擊、滾動、拖拽等事件。我們通常把一些耗時的操作放在其他線程，比如說圖片下載、文件上傳等耗時操作。而當(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ù) 1
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        
        // 回到主線程
        dispatch_async(mainQueue, ^{
            // 追加在主線程中執(zhí)行的任務(wù)
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        });
    });
}

可以看到在其他線程中先執(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 方法會等待前邊追加到并發(fā)隊列中的任務(wù)全部執(zhí)行完畢之后，再將指定的任務(wù)追加到該異步隊列中。然后在 dispatch_barrier_async 方法追加的任務(wù)執(zhí)行完畢之后，異步隊列才恢復(fù)為一般動作，接著追加任務(wù)到該異步隊列并開始執(zhí)行。具體如下圖所示：

dispatch_barrier_async.png

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

在 dispatch_barrier_async 執(zhí)行結(jié)果中可以看出：

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

6.2 GCD 延時執(zhí)行方法：dispatch_after

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

/**
 * 延時執(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)前線程
    });
}

6.3 GCD 一次性代碼（只執(zhí)行一次）：dispatch_once

我們在創(chuàng)建單例、或者有整個程序運(yùn)行過程中只執(zhí)行一次的代碼時，我們就用到了 GCD 的 dispatch_once 方法。使用 dispatch_once 方法能保證某段代碼在程序運(yùn)行過程中只被執(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 給我們提供了快速迭代的方法 dispatch_apply。dispatch_apply 按照指定的次數(shù)將指定的任務(wù)追加到指定的隊列中，并等待全部隊列執(zhí)行結(jié)束。

如果是在串行隊列中使用 dispatch_apply，那么就和 for 循環(huán)一樣，按順序同步執(zhí)行。但是這樣就體現(xiàn)不出快速迭代的意義了。

我們可以利用并發(fā)隊列進(jìn)行異步執(zhí)行。比如說遍歷 0~5 這 6 個數(shù)字，for 循環(huán)的做法是每次取出一個元素，逐個遍歷。dispatch_apply 可以在多個線程中同時（異步）遍歷多個數(shù)字。

還有一點(diǎn)，無論是在串行隊列，還是并發(fā)隊列中，dispatch_apply 都會等待全部任務(wù)執(zhí)行完畢，這點(diǎn)就像是同步操作，也像是隊列組中的 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");
}

6.5 GCD 隊列組：dispatch_group

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

調(diào)用隊列組的 dispatch_group_async 先把任務(wù)放到隊列中，然后將隊列放入隊列組中?；蛘呤褂藐犃薪M的 dispatch_group_enter、dispatch_group_leave 組合來實(shí)現(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ù)。

/**
 * 隊列組 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
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任務(wù) 2
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的異步任務(wù) 1、任務(wù) 2 都執(zhí)行完畢后，回到主線程執(zhí)行下邊任務(wù)
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程

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

從 dispatch_group_notify 相關(guān)代碼運(yùn)行輸出結(jié)果可以看出：
當(dāng)所有任務(wù)都執(zhí)行完成之后，才執(zhí)行 dispatch_group_notify 相關(guān) block 中的任務(wù)。

6.5.2 dispatch_group_wait

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

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

從 dispatch_group_wait 相關(guān)代碼運(yù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ù)。

/**
 * 隊列組 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
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程

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

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

6.6 GCD 信號量：dispatch_semaphore

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

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

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

Dispatch Semaphore 在實(shí)際開發(fā)中主要用于：

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

6.6.1 Dispatch Semaphore 線程同步

我們在開發(fā)中，會遇到這樣的需求：異步執(zhí)行耗時任務(wù)，并使用異步執(zhí)行的結(jié)果進(jìn)行一些額外的操作。換句話說，相當(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 實(shí)現(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);
}

從 Dispatch Semaphore 實(shí)現(xiàn)線程同步的代碼可以看到：

semaphore---end 是在執(zhí)行完 number = 100; 之后才打印的。而且輸出結(jié)果 number 為 100。這是因?yàn)?異步執(zhí)行不會做任何等待，可以繼續(xù)執(zhí)行任務(wù)。
執(zhí)行順如下：
1.semaphore 初始創(chuàng)建時計數(shù)為 0。
2.異步執(zhí)行將任務(wù) 1 追加到隊列之后，不做等待，接著執(zhí)行 dispatch_semaphore_wait 方法，semaphore 減 1，此時 semaphore == -1，當(dāng)前線程進(jìn)入等待狀態(tài)。
3.然后，異步任務(wù) 1 開始執(zhí)行。任務(wù) 1 執(zhí)行到 dispatch_semaphore_signal 之后，總信號量加 1，此時 semaphore == 0，正在被阻塞的線程（主線程）恢復(fù)繼續(xù)執(zhí)行。
4.最后打印 semaphore---end,number = 100。

這樣就實(shí)現(xiàn)了線程同步，將異步執(zhí)行任務(wù)轉(zhuǎn)換為同步執(zhí)行任務(wù)。

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

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

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

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

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

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

場景：總共有 50 張火車票，有兩個售賣火車票的窗口，一個是北京火車票售賣窗口，另一個是上?；疖嚻笔圪u窗口。兩個窗口同時售賣火車票，賣完為止。

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

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

/**
 * 非線程安全：不使用 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;
        }
        
    }
}

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

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

/**
 * 線程安全：使用 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);
    }
}

可以看出，在考慮了線程安全的情況下，使用 dispatch_semaphore機(jī)制之后，得到的票數(shù)是正確的，沒有出現(xiàn)混亂的情況。我們也就解決了多個線程同步的問題。
參考資料：

書籍：『Objective-C 高級編程 iOS 與 OS X 多線程和內(nèi)存管理』
博文：iOS GCD 之 dispatch_semaphore（信號量）

iOS 多線程詳盡總結(jié)系列文章：

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av

iOS GCD