• 本文首發(fā)于我的個人博客：「程序員充電站」
• 文章鏈接：「傳送門」
• 本文更新時間： 2019-09-14 15:35:48

再次感謝大家對這篇文章的喜歡和支持兼蜈。為了更好的讓大家了解 iOS 多線程固灵，以及 GCD 的相關(guān)知識值戳，我第三次對這篇文章進(jìn)行了梳理锣光，修改了 GCD 不同組合方式區(qū)別的相關(guān)總結(jié)，以及 隊列蔬浙、任務(wù)以及線程之間關(guān)系的形象理解猪落。

本文用來介紹 iOS 多線程中 GCD 的相關(guān)知識以及使用方法。這大概是史上最詳細(xì)畴博、清晰的關(guān)于 GCD 的詳細(xì)講解 + 總結(jié) 的文章了笨忌。通過本文俱病，您將了解到：
1. GCD 簡介
2. GCD 任務(wù)和隊列
3. GCD 的使用步驟
4. GCD 的基本使用（六種組合不同區(qū)別煤裙，隊列嵌套情況區(qū)別诈胜，相互關(guān)系形象理解）
5. GCD 線程間的通信
6. GCD 的其他方法（柵欄方法：dispatch_barrier_async垦写、延時執(zhí)行方法：dispatch_after咆疗、一次性代碼（只執(zhí)行一次）：dispatch_once登颓、快速迭代方法：dispatch_apply者铜、隊列組：dispatch_group压恒、信號量：dispatch_semaphore）

文中 Demo 我已放在了 Github 上早歇，Demo 鏈接：傳送門

1. GCD 簡介

什么是 『GCD』 倾芝？我們先來看看百度百科的解釋簡單了解下相關(guān)概念。

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

GCD 擁有以上這么多的好處脐雪，而且在多線程中處于舉足輕重的地位厌小。那么我們就很有必要系統(tǒng)地學(xué)習(xí)一下 GCD 的使用方法。

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

學(xué)習(xí) GCD 之前战秋，先來了解 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 的使用步驟其實很簡單劲蜻，只有兩步：

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ù)表示隊列的唯一標(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() 方法獲得主隊列阅束。

注意：主隊列其實并不特殊呼胚。 主隊列的實質(zhì)上就是一個普通的串行隊列，只是因為默認(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í)行）笆搓，那么我們就有了四種不同的組合方式。這四種不同的組合方式是：

1. 同步執(zhí)行 + 并發(fā)隊列
2. 異步執(zhí)行 + 并發(fā)隊列
3. 同步執(zhí)行 + 串行隊列
4. 異步執(zhí)行 + 串行隊列

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

5. 同步執(zhí)行 + 主隊列
6. 異步執(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ū)別：

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

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

除了上邊提到的『主線程』中調(diào)用『主隊列』+『同步執(zhí)行』會導(dǎo)致死鎖問題徽曲。實際在使用『串行隊列』的時候零截，也可能出現(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)一步說明了主隊列其實并不特殊序攘。

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

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

好了晶姊，關(guān)于『不同隊列』+『不同任務(wù)』 組合不同區(qū)別總結(jié)就到這里。

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

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

他的問題：

在 異步 + 并發(fā) 中的解釋：
（異步執(zhí)行具備開啟新線程的能力碱呼。且并發(fā)隊列可開啟多個線程蒙挑，同時執(zhí)行多個任務(wù)）

以及 同步 + 并發(fā) 中的解釋：
（雖然并發(fā)隊列可以開啟多個線程，并且同時執(zhí)行多個任務(wù)愚臀。但是因為本身不能創(chuàng)建新線程先慷，只有當(dāng)前線程這一個線程（同步任務(wù)不具備開啟新線程的能力）

這個地方看起來有點疑惑艾猜，你兩個地方分別提到：異步執(zhí)行開啟新線程拷肌，并發(fā)隊列也可以開啟新線程黔攒，想請教下，你的意思是只有任務(wù)才擁有創(chuàng)建新線程的能力舶斧，而隊列只有開啟線程的能力欣鳖，并不能創(chuàng)建線程 ？這二者是這樣的關(guān)聯(lián)嗎茴厉？

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

假設(shè)現(xiàn)在有 5 個人要穿過一道門禁稻爬，這道門禁總共有 10 個入口，管理員可以決定同一時間打開幾個入口胰坟，可以決定同一時間讓一個人單獨通過還是多個人一起通過因篇。不過默認(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 個人雖然都想快點過去殃恒，但是 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ā)隊列
 * 特點：在當(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");
}

輸出結(jié)果：
2019-08-08 14:32:53.542816+0800 YSC-GCD-demo[16332:4171500] currentThread---<NSThread: 0x600002326940>{number = 1, name = main}
2019-08-08 14:32:53.542964+0800 YSC-GCD-demo[16332:4171500] syncConcurrent---begin
2019-08-08 14:32:55.544329+0800 YSC-GCD-demo[16332:4171500] 1---<NSThread: 0x600002326940>{number = 1, name = main}
2019-08-08 14:32:57.545779+0800 YSC-GCD-demo[16332:4171500] 2---<NSThread: 0x600002326940>{number = 1, name = main}
2019-08-08 14:32:59.547154+0800 YSC-GCD-demo[16332:4171500] 3---<NSThread: 0x600002326940>{number = 1, name = main}
2019-08-08 14:32:59.547365+0800 YSC-GCD-demo[16332:4171500] 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ù)婆排。但是因為本身不能創(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ā)隊列
 * 特點：可以開啟多個線程，任務(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");
}

輸出結(jié)果：
2019-08-08 14:36:37.747966+0800 YSC-GCD-demo[17232:4187114] currentThread---<NSThread: 0x60000206d380>{number = 1, name = main}
2019-08-08 14:36:37.748150+0800 YSC-GCD-demo[17232:4187114] asyncConcurrent---begin
2019-08-08 14:36:37.748279+0800 YSC-GCD-demo[17232:4187114] asyncConcurrent---end
2019-08-08 14:36:39.752523+0800 YSC-GCD-demo[17232:4187204] 2---<NSThread: 0x600002010980>{number = 3, name = (null)}
2019-08-08 14:36:39.752527+0800 YSC-GCD-demo[17232:4187202] 3---<NSThread: 0x600002018480>{number = 5, name = (null)}
2019-08-08 14:36:39.752527+0800 YSC-GCD-demo[17232:4187203] 1---<NSThread: 0x600002023400>{number = 4, 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í)行 + 串行隊列
 * 特點：不會開啟新線程，在當(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");
}

輸出結(jié)果為：
2019-08-08 14:39:31.366815+0800 YSC-GCD-demo[17285:4197645] currentThread---<NSThread: 0x600001b5e940>{number = 1, name = main}
2019-08-08 14:39:31.366952+0800 YSC-GCD-demo[17285:4197645] syncSerial---begin
2019-08-08 14:39:33.368256+0800 YSC-GCD-demo[17285:4197645] 1---<NSThread: 0x600001b5e940>{number = 1, name = main}
2019-08-08 14:39:35.369661+0800 YSC-GCD-demo[17285:4197645] 2---<NSThread: 0x600001b5e940>{number = 1, name = main}
2019-08-08 14:39:37.370991+0800 YSC-GCD-demo[17285:4197645] 3---<NSThread: 0x600001b5e940>{number = 1, name = main}
2019-08-08 14:39:37.371192+0800 YSC-GCD-demo[17285:4197645] 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í)行 + 串行隊列

• 會開啟新線程拱礁，但是因為任務(wù)是串行的，執(zhí)行完一個任務(wù)辕漂，再執(zhí)行下一個任務(wù)

/**
 * 異步執(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
        [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");
}

輸出結(jié)果為：
2019-08-08 14:40:53.944502+0800 YSC-GCD-demo[17313:4203018] currentThread---<NSThread: 0x6000015da940>{number = 1, name = main}
2019-08-08 14:40:53.944615+0800 YSC-GCD-demo[17313:4203018] asyncSerial---begin
2019-08-08 14:40:53.944710+0800 YSC-GCD-demo[17313:4203018] asyncSerial---end
2019-08-08 14:40:55.947709+0800 YSC-GCD-demo[17313:4203079] 1---<NSThread: 0x6000015a0840>{number = 3, name = (null)}
2019-08-08 14:40:57.952453+0800 YSC-GCD-demo[17313:4203079] 2---<NSThread: 0x6000015a0840>{number = 3, name = (null)}
2019-08-08 14:40:59.952943+0800 YSC-GCD-demo[17313:4203079] 3---<NSThread: 0x6000015a0840>{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à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
        [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");
}

輸出結(jié)果
2019-08-08 14:43:58.062376+0800 YSC-GCD-demo[17371:4213562] currentThread---<NSThread: 0x6000026e2940>{number = 1, name = main}
2019-08-08 14:43:58.062518+0800 YSC-GCD-demo[17371:4213562] syncMain---begin
(lldb)

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

• 追加到主線程的任務(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é)果：
2019-08-08 14:51:38.137978+0800 YSC-GCD-demo[17482:4237818] currentThread---<NSThread: 0x600001dd6c00>{number = 3, name = (null)}
2019-08-08 14:51:38.138159+0800 YSC-GCD-demo[17482:4237818] syncMain---begin
2019-08-08 14:51:40.149065+0800 YSC-GCD-demo[17482:4237594] 1---<NSThread: 0x600001d8d380>{number = 1, name = main}
2019-08-08 14:51:42.151104+0800 YSC-GCD-demo[17482:4237594] 2---<NSThread: 0x600001d8d380>{number = 1, name = main}
2019-08-08 14:51:44.152583+0800 YSC-GCD-demo[17482:4237594] 3---<NSThread: 0x600001d8d380>{number = 1, name = main}
2019-08-08 14:51:44.152767+0800 YSC-GCD-demo[17482:4237818] syncMain---end

在其他線程中使用 同步執(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)在就不會卡住了呢粒褒？

因為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---%@",[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");
}

輸出結(jié)果：
2019-08-08 14:53:27.023091+0800 YSC-GCD-demo[17521:4243690] currentThread---<NSThread: 0x6000022a1380>{number = 1, name = main}
2019-08-08 14:53:27.023247+0800 YSC-GCD-demo[17521:4243690] asyncMain---begin
2019-08-08 14:53:27.023399+0800 YSC-GCD-demo[17521:4243690] asyncMain---end
2019-08-08 14:53:29.035565+0800 YSC-GCD-demo[17521:4243690] 1---<NSThread: 0x6000022a1380>{number = 1, name = main}
2019-08-08 14:53:31.036565+0800 YSC-GCD-demo[17521:4243690] 2---<NSThread: 0x6000022a1380>{number = 1, name = main}
2019-08-08 14:53:33.037092+0800 YSC-GCD-demo[17521:4243690] 3---<NSThread: 0x6000022a1380>{number = 1, name = main}

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

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

弄懂了難理解、繞來繞去的『不同隊列』+『不同任務(wù)』使用區(qū)別之后蛹磺，我們來學(xué)習(xí)一個簡單的東西：5. GCD 線程間的通信粟瞬。

5. GCD 線程間的通信

在 iOS 開發(fā)過程中，我們一般在主線程里邊進(jìn)行 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ù) 1
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        
        // 回到主線程
        dispatch_async(mainQueue, ^{
            // 追加在主線程中執(zhí)行的任務(wù)
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        });
    });
}

輸出結(jié)果：
2019-08-08 14:56:22.973318+0800 YSC-GCD-demo[17573:4253201] 1---<NSThread: 0x600001846080>{number = 3, name = (null)}
2019-08-08 14:56:24.973902+0800 YSC-GCD-demo[17573:4253108] 2---<NSThread: 0x60000181e940>{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 方法會等待前邊追加到并發(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)前線程
    });
}

輸出結(jié)果：
2019-08-08 14:59:02.540868+0800 YSC-GCD-demo[17648:4262933] 1---<NSThread: 0x600001ca4c40>{number = 3, name = (null)}
2019-08-08 14:59:02.540868+0800 YSC-GCD-demo[17648:4262932] 2---<NSThread: 0x600001c84a00>{number = 4, name = (null)}
2019-08-08 14:59:04.542346+0800 YSC-GCD-demo[17648:4262933] barrier---<NSThread: 0x600001ca4c40>{number = 3, name = (null)}
2019-08-08 14:59:06.542772+0800 YSC-GCD-demo[17648:4262932] 4---<NSThread: 0x600001c84a00>{number = 4, name = (null)}
2019-08-08 14:59:06.542773+0800 YSC-GCD-demo[17648:4262933] 3---<NSThread: 0x600001ca4c40>{number = 3, name = (null)}

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

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

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

我們經(jīng)常會遇到這樣的需求：在指定時間（例如 3 秒）之后執(zhí)行某個任務(wù)〕洌可以用 GCD 的dispatch_after 方法來實現(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)前線程
    });
}

輸出結(jié)果：
2019-08-08 15:01:33.569710+0800 YSC-GCD-demo[17702:4272430] currentThread---<NSThread: 0x600001ead340>{number = 1, name = main}
2019-08-08 15:01:33.569838+0800 YSC-GCD-demo[17702:4272430] asyncMain---begin
2019-08-08 15:01:35.570146+0800 YSC-GCD-demo[17702:4272430] after---<NSThread: 0x600001ead340>{number = 1, name = main}

可以看出：在打印 asyncMain---begin 之后大約 2.0 秒的時間伤疙，打印了 after---<NSThread: 0x600001ead340>{number = 1, name = main}

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ù)字。

還有一點犁功，無論是在串行隊列氓轰，還是并發(fā)隊列中，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é)果：
2019-08-08 15:05:04.715266+0800 YSC-GCD-demo[17771:4285619] apply---begin
2019-08-08 15:05:04.715492+0800 YSC-GCD-demo[17771:4285619] 0---<NSThread: 0x600003bd1380>{number = 1, name = main}
2019-08-08 15:05:04.715516+0800 YSC-GCD-demo[17771:4285722] 1---<NSThread: 0x600003b82340>{number = 3, name = (null)}
2019-08-08 15:05:04.715526+0800 YSC-GCD-demo[17771:4285720] 3---<NSThread: 0x600003ba4cc0>{number = 5, name = (null)}
2019-08-08 15:05:04.715564+0800 YSC-GCD-demo[17771:4285721] 2---<NSThread: 0x600003bb9a80>{number = 7, name = (null)}
2019-08-08 15:05:04.715555+0800 YSC-GCD-demo[17771:4285719] 4---<NSThread: 0x600003b98100>{number = 6, name = (null)}
2019-08-08 15:05:04.715578+0800 YSC-GCD-demo[17771:4285728] 5---<NSThread: 0x600003beb400>{number = 4, name = (null)}
2019-08-08 15:05:04.715677+0800 YSC-GCD-demo[17771:4285619] apply---end

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

6.5 GCD 隊列組：dispatch_group

有時候我們會有這樣的需求：分別異步執(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ù)衰猛。

/**
 * 隊列組 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");
    });
}

輸出結(jié)果：
2019-08-08 15:07:21.601734+0800 YSC-GCD-demo[17813:4293874] currentThread---<NSThread: 0x600003aad380>{number = 1, name = main}
2019-08-08 15:07:21.601871+0800 YSC-GCD-demo[17813:4293874] group---begin
2019-08-08 15:07:23.604854+0800 YSC-GCD-demo[17813:4294048] 2---<NSThread: 0x600003add100>{number = 4, name = (null)}
2019-08-08 15:07:23.604852+0800 YSC-GCD-demo[17813:4294053] 1---<NSThread: 0x600003ace4c0>{number = 3, name = (null)}
2019-08-08 15:07:25.606067+0800 YSC-GCD-demo[17813:4293874] 3---<NSThread: 0x600003aad380>{number = 1, name = main}
2019-08-08 15:07:25.606255+0800 YSC-GCD-demo[17813:4293874] 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");
    
}

輸出結(jié)果：
2019-08-08 15:09:12.441729+0800 YSC-GCD-demo[17844:4299926] currentThread---<NSThread: 0x6000013e2940>{number = 1, name = main}
2019-08-08 15:09:12.441870+0800 YSC-GCD-demo[17844:4299926] group---begin
2019-08-08 15:09:14.445790+0800 YSC-GCD-demo[17844:4300046] 2---<NSThread: 0x600001389780>{number = 4, name = (null)}
2019-08-08 15:09:14.445760+0800 YSC-GCD-demo[17844:4300043] 1---<NSThread: 0x600001381880>{number = 3, name = (null)}
2019-08-08 15:09:14.446039+0800 YSC-GCD-demo[17844:4299926] 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");
    });
}

輸出結(jié)果：
2019-08-08 15:13:17.983283+0800 YSC-GCD-demo[17924:4314716] currentThread---<NSThread: 0x600001ee5380>{number = 1, name = main}
2019-08-08 15:13:17.983429+0800 YSC-GCD-demo[17924:4314716] group---begin
2019-08-08 15:13:19.988898+0800 YSC-GCD-demo[17924:4314816] 2---<NSThread: 0x600001e9ca00>{number = 3, name = (null)}
2019-08-08 15:13:19.988888+0800 YSC-GCD-demo[17924:4314808] 1---<NSThread: 0x600001e94100>{number = 4, name = (null)}
2019-08-08 15:13:21.990450+0800 YSC-GCD-demo[17924:4314716] 3---<NSThread: 0x600001ee5380>{number = 1, name = main}
2019-08-08 15:13:21.990711+0800 YSC-GCD-demo[17924:4314716] 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 組合苗沧，其實等同于dispatch_group_async刊棕。

6.6 GCD 信號量：dispatch_semaphore

GCD 中的信號量是指 Dispatch Semaphore，是持有計數(shù)的信號待逞。類似于過高速路收費站的欄桿甥角。可以通過時识樱，打開欄桿嗤无，不可以通過時，關(guān)閉欄桿怜庸。在 Dispatch Semaphore 中当犯，使用計數(shù)來完成這個功能，計數(shù)小于 0 時需要等待割疾，不可通過嚎卫。計數(shù)為 0 或大于 0 時，不用等待宏榕，可通過拓诸。計數(shù)大于 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 在實際開發(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 實現(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é)果：
2019-08-08 15:16:56.781543+0800 YSC-GCD-demo[17988:4325744] currentThread---<NSThread: 0x60000298d380>{number = 1, name = main}
2019-08-08 15:16:56.781698+0800 YSC-GCD-demo[17988:4325744] semaphore---begin
2019-08-08 15:16:58.785232+0800 YSC-GCD-demo[17988:4325867] 1---<NSThread: 0x6000029eba80>{number = 3, name = (null)}
2019-08-08 15:16:58.785432+0800 YSC-GCD-demo[17988:4325744] semaphore---end,number = 100

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

• semaphore---end 是在執(zhí)行完 number = 100; 之后才打印的固耘。而且輸出結(jié)果 number 為 100题篷。這是因為 異步執(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。

這樣就實現(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é)束操作)，另一個再說(另一個線程再開始操作)念搬。

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

場景：總共有 50 張火車票首妖，有兩個售賣火車票的窗口，一個是北京火車票售賣窗口爷恳，另一個是上河欣拢火車票售賣窗口。兩個窗口同時售賣火車票温亲，賣完為止棚壁。

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;
        }
        
    }
}

輸出結(jié)果（部分）：
2019-08-08 15:21:39.772655+0800 YSC-GCD-demo[18071:4340555] currentThread---<NSThread: 0x6000015a2f40>{number = 1, name = main}
2019-08-08 15:21:39.772790+0800 YSC-GCD-demo[18071:4340555] semaphore---begin
2019-08-08 15:21:39.773101+0800 YSC-GCD-demo[18071:4340604] 剩余票數(shù)：48 窗口：<NSThread: 0x6000015cc600>{number = 4, name = (null)}
2019-08-08 15:21:39.773115+0800 YSC-GCD-demo[18071:4340605] 剩余票數(shù)：49 窗口：<NSThread: 0x6000015f8600>{number = 3, name = (null)}
2019-08-08 15:21:39.975041+0800 YSC-GCD-demo[18071:4340605] 剩余票數(shù)：47 窗口：<NSThread: 0x6000015f8600>{number = 3, name = (null)}
2019-08-08 15:21:39.975037+0800 YSC-GCD-demo[18071:4340604] 剩余票數(shù)：47 窗口：<NSThread: 0x6000015cc600>{number = 4, name = (null)}
2019-08-08 15:21:40.176567+0800 YSC-GCD-demo[18071:4340604] 剩余票數(shù)：46 窗口：<NSThread: 0x6000015cc600>{number = 4, name = (null)}
...

可以看到在不考慮線程安全曼验，不使用 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);
    }
}

輸出結(jié)果為：
2019-08-08 15:23:58.819891+0800 YSC-GCD-demo[18116:4348091] currentThread---<NSThread: 0x600000681380>{number = 1, name = main}
2019-08-08 15:23:58.820041+0800 YSC-GCD-demo[18116:4348091] semaphore---begin
2019-08-08 15:23:58.820305+0800 YSC-GCD-demo[18116:4348159] 剩余票數(shù)：49 窗口：<NSThread: 0x6000006ede80>{number = 3, name = (null)}
2019-08-08 15:23:59.022165+0800 YSC-GCD-demo[18116:4348157] 剩余票數(shù)：48 窗口：<NSThread: 0x6000006e4b40>{number = 4, name = (null)}
2019-08-08 15:23:59.225299+0800 YSC-GCD-demo[18116:4348159] 剩余票數(shù)：47 窗口：<NSThread: 0x6000006ede80>{number = 3, name = (null)}
...
2019-08-08 15:24:08.355977+0800 YSC-GCD-demo[18116:4348157] 剩余票數(shù)：2 窗口：<NSThread: 0x6000006e4b40>{number = 4, name = (null)}
2019-08-08 15:24:08.559201+0800 YSC-GCD-demo[18116:4348159] 剩余票數(shù)：1 窗口：<NSThread: 0x6000006ede80>{number = 3, name = (null)}
2019-08-08 15:24:08.759630+0800 YSC-GCD-demo[18116:4348157] 剩余票數(shù)：0 窗口：<NSThread: 0x6000006e4b40>{number = 4, name = (null)}
2019-08-08 15:24:08.965100+0800 YSC-GCD-demo[18116:4348159] 所有火車票均已售完
2019-08-08 15:24:08.965440+0800 YSC-GCD-demo[18116:4348157] 所有火車票均已售完

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

參考資料：

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

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

• iOS多線程：『pthread、NSThread』詳盡總結(jié)
• iOS多線程：『GCD』詳盡總結(jié)
• iOS多線程：『NSOperation』詳盡總結(jié)
• iOS多線程：『RunLoop』詳盡總結(jié)

• 本文作者： 行走少年郎
• 本文鏈接： http://www.reibang.com/p/2d57c72016c6
• 版權(quán)聲明： 本文章采用 CC BY-NC-SA 3.0 許可協(xié)議钾菊。轉(zhuǎn)載請在文字開頭注明『本文作者』和『本文鏈接』帅矗！