本文用來介紹 iOS 多線程中 GCD 的相關知識以及使用方法。這大概是史上最詳細、清晰的關於 GCD 的詳細講解+總結的文章了。經過本文,您將瞭解到:
1. GCD 簡介
2. GCD 任務和隊列
3. GCD 的使用步驟
4. GCD 的基本使用(6種不一樣組合區別)
5. GCD 線程間的通訊
6. GCD 的其餘方法(柵欄方法:dispatch_barrier_async、延時執行方法:dispatch_after、一次性代碼(只執行一次):dispatch_once、快速迭代方法:dispatch_apply、隊列組:dispatch_group、信號量:dispatch_semaphore)文中 Demo 我已放在了 Github 上,Demo 連接:傳送門html
什麼是 GCD 呢?咱們先來看看百度百科的解釋簡單瞭解下概念git
引自 百度百科
Grand Central Dispatch(GCD) 是 Apple 開發的一個多核編程的較新的解決方法。它主要用於優化應用程序以支持多核處理器以及其餘對稱多處理系統。它是一個在線程池模式的基礎上執行的併發任務。在 Mac OS X 10.6 雪豹中首次推出,也可在 iOS 4 及以上版本使用。
爲何要用 GCD 呢?程序員
由於 GCD 有不少好處啊,具體以下:github
既然 GCD 有這麼多的好處,那麼下面咱們就來系統的學習一下 GCD 的使用方法。編程
學習 GCD 以前,先來了解 GCD 中兩個核心概念:任務和隊列。安全
任務:就是執行操做的意思,換句話說就是你在線程中執行的那段代碼。在 GCD 中是放在 block 中的。執行任務有兩種方式:同步執行(sync)和異步執行(async)。二者的主要區別是:是否等待隊列的任務執行結束,以及是否具有開啓新線程的能力。session
同步執行(sync):多線程
異步執行(async):併發
舉個簡單例子:你要打電話給小明和小白。
同步執行就是,你打電話給小明的時候,不能同時打給小白,等到給小明打完了,才能打給小白(等待任務執行結束)。並且只能用當前的電話(不具有開啓新線程的能力)。
而異步執行就是,你打電話給小明的時候,不等和小明通話結束,還能直接給小白打電話,不用等着和小明通話結束再打(不用等待任務執行結束)。除了當前電話,你還可使用其餘所能使用的電話(具有開啓新線程的能力)。app
注意: 異步執行(async)雖然具備開啓新線程的能力,可是並不必定開啓新線程。這跟任務所指定的隊列類型有關(下面會講)。
隊列(Dispatch Queue):這裏的隊列指執行任務的等待隊列,即用來存聽任務的隊列。隊列是一種特殊的線性表,採用 FIFO(先進先出)的原則,即新任務老是被插入到隊列的末尾,而讀取任務的時候老是從隊列的頭部開始讀取。每讀取一個任務,則從隊列中釋放一個任務。隊列的結構可參考下圖:
在 GCD 中有兩種隊列:串行隊列和併發隊列。二者都符合 FIFO(先進先出)的原則。二者的主要區別是:執行順序不一樣,以及開啓線程數不一樣。
串行隊列(Serial Dispatch Queue):
併發隊列(Concurrent Dispatch Queue):
注意: 併發隊列的併發功能只有在異步(dispatch_async)函數下才有效
二者具體區別以下兩圖所示。
GCD 的使用步驟其實很簡單,只有兩步。
下邊來看看隊列的建立方法/獲取方法,以及任務的建立方法。
dispatch_queue_create
來建立隊列,須要傳入兩個參數,第一個參數表示隊列的惟一標識符,用於 DEBUG,可爲空,Dispatch Queue 的名稱推薦使用應用程序 ID 這種逆序全程域名;第二個參數用來識別是串行隊列仍是併發隊列。DISPATCH_QUEUE_SERIAL
表示串行隊列,DISPATCH_QUEUE_CONCURRENT
表示併發隊列。// 串行隊列的建立方法 dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL); // 併發隊列的建立方法 dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
對於串行隊列,GCD 提供了的一種特殊的串行隊列:主隊列(Main Dispatch Queue)。
dispatch_get_main_queue()
得到主隊列。// 主隊列的獲取方法 dispatch_queue_t queue = dispatch_get_main_queue();
對於併發隊列,GCD 默認提供了全局併發隊列(Global Dispatch Queue)。
dispatch_get_global_queue
來獲取。須要傳入兩個參數。第一個參數表示隊列優先級,通常用DISPATCH_QUEUE_PRIORITY_DEFAULT
。第二個參數暫時沒用,用0
便可。// 全局併發隊列的獲取方法 dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
GCD 提供了同步執行任務的建立方法dispatch_sync
和異步執行任務建立方法dispatch_async
。
// 同步執行任務建立方法 dispatch_sync(queue, ^{ // 這裏放同步執行任務代碼 }); // 異步執行任務建立方法 dispatch_async(queue, ^{ // 這裏放異步執行任務代碼 });
雖然使用 GCD 只需兩步,可是既然咱們有兩種隊列(串行隊列/併發隊列),兩種任務執行方式(同步執行/異步執行),那麼咱們就有了四種不一樣的組合方式。這四種不一樣的組合方式是:
- 同步執行 + 併發隊列
- 異步執行 + 併發隊列
- 同步執行 + 串行隊列
- 異步執行 + 串行隊列
實際上,剛纔還說了兩種特殊隊列:全局併發隊列、主隊列。全局併發隊列能夠做爲普通併發隊列來使用。可是主隊列由於有點特殊,因此咱們就又多了兩種組合方式。這樣就有六種不一樣的組合方式了。
- 同步執行 + 主隊列
- 異步執行 + 主隊列
那麼這幾種不一樣組合方式各有什麼區別呢,這裏爲了方便,先上結果,再來說解。你能夠直接查看錶格結果,而後跳過 4. GCD的基本使用 。
區別 | 併發隊列 | 串行隊列 | 主隊列 |
---|---|---|---|
同步(sync) | 沒有開啓新線程,串行執行任務 | 沒有開啓新線程,串行執行任務 | 主線程調用:死鎖卡住不執行 其餘線程調用:沒有開啓新線程,串行執行任務 |
異步(async) | 有開啓新線程,併發執行任務 | 有開啓新線程(1條),串行執行任務 | 沒有開啓新線程,串行執行任務 |
下邊咱們來分別講講這幾種不一樣的組合方式的使用方法。
先來說講併發隊列的兩種執行方式。
/** * 同步執行 + 併發隊列 * 特色:在當前線程中執行任務,不會開啓新線程,執行完一個任務,再執行下一個任務。 */ - (void)syncConcurrent { NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程 NSLog(@"syncConcurrent---begin"); dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT); dispatch_sync(queue, ^{ // 追加任務1 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程 } }); dispatch_sync(queue, ^{ // 追加任務2 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"2---%@",[NSThread currentThread]); // 打印當前線程 } }); dispatch_sync(queue, ^{ // 追加任務3 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"3---%@",[NSThread currentThread]); // 打印當前線程 } }); NSLog(@"syncConcurrent---end"); }
輸出結果:
2018-02-23 20:34:55.095932+0800 YSC-GCD-demo[19892:4996930] currentThread---<NSThread: 0x60400006bbc0>{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---<NSThread: 0x60400006bbc0>{number = 1, name = main}
2018-02-23 20:34:59.099100+0800 YSC-GCD-demo[19892:4996930] 1---<NSThread: 0x60400006bbc0>{number = 1, name = main}
2018-02-23 20:35:01.099843+0800 YSC-GCD-demo[19892:4996930] 2---<NSThread: 0x60400006bbc0>{number = 1, name = main}
2018-02-23 20:35:03.101171+0800 YSC-GCD-demo[19892:4996930] 2---<NSThread: 0x60400006bbc0>{number = 1, name = main}
2018-02-23 20:35:05.101750+0800 YSC-GCD-demo[19892:4996930] 3---<NSThread: 0x60400006bbc0>{number = 1, name = main}
2018-02-23 20:35:07.102414+0800 YSC-GCD-demo[19892:4996930] 3---<NSThread: 0x60400006bbc0>{number = 1, name = main}
2018-02-23 20:35:07.102575+0800 YSC-GCD-demo[19892:4996930] syncConcurrent---end
從同步執行 + 併發隊列
中可看到:
同步執行
不具有開啓新線程的能力)。syncConcurrent---begin
和syncConcurrent---end
之間執行的(同步任務
須要等待隊列的任務執行結束)。併發隊列
能夠開啓多個線程,而且同時執行多個任務。可是由於自己不能建立新線程,只有當前線程這一個線程(同步任務
不具有開啓新線程的能力),因此也就不存在併發。並且當前線程只有等待當前隊列中正在執行的任務執行完畢以後,才能繼續接着執行下面的操做(同步任務
須要等待隊列的任務執行結束)。因此任務只能一個接一個按順序執行,不能同時被執行。/** * 異步執行 + 併發隊列 * 特色:能夠開啓多個線程,任務交替(同時)執行。 */ - (void)asyncConcurrent { NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程 NSLog(@"asyncConcurrent---begin"); dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT); dispatch_async(queue, ^{ // 追加任務1 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程 } }); dispatch_async(queue, ^{ // 追加任務2 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"2---%@",[NSThread currentThread]); // 打印當前線程 } }); dispatch_async(queue, ^{ // 追加任務3 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"3---%@",[NSThread currentThread]); // 打印當前線程 } }); NSLog(@"asyncConcurrent---end"); }
輸出結果:
2018-02-23 20:36:41.769269+0800 YSC-GCD-demo[19929:5005237] currentThread---<NSThread: 0x604000062d80>{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---<NSThread: 0x604000266f00>{number = 5, name = (null)}
2018-02-23 20:36:43.774440+0800 YSC-GCD-demo[19929:5005567] 3---<NSThread: 0x60000026f200>{number = 4, name = (null)}
2018-02-23 20:36:43.774440+0800 YSC-GCD-demo[19929:5005565] 1---<NSThread: 0x600000264800>{number = 3, name = (null)}
2018-02-23 20:36:45.779286+0800 YSC-GCD-demo[19929:5005567] 3---<NSThread: 0x60000026f200>{number = 4, name = (null)}
2018-02-23 20:36:45.779302+0800 YSC-GCD-demo[19929:5005565] 1---<NSThread: 0x600000264800>{number = 3, name = (null)}
2018-02-23 20:36:45.779286+0800 YSC-GCD-demo[19929:5005566] 2---<NSThread: 0x604000266f00>{number = 5, name = (null)}
在異步執行 + 併發隊列
中能夠看出:
異步執行
具有開啓新線程的能力。且併發隊列
可開啓多個線程,同時執行多個任務)。syncConcurrent---begin
和syncConcurrent---end
以後才執行的。說明當前線程沒有等待,而是直接開啓了新線程,在新線程中執行任務(異步執行
不作等待,能夠繼續執行任務)。接下來再來說講串行隊列的兩種執行方式。
/** * 同步執行 + 串行隊列 * 特色:不會開啓新線程,在當前線程執行任務。任務是串行的,執行完一個任務,再執行下一個任務。 */ - (void)syncSerial { NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程 NSLog(@"syncSerial---begin"); dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL); dispatch_sync(queue, ^{ // 追加任務1 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程 } }); dispatch_sync(queue, ^{ // 追加任務2 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"2---%@",[NSThread currentThread]); // 打印當前線程 } }); dispatch_sync(queue, ^{ // 追加任務3 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"3---%@",[NSThread currentThread]); // 打印當前線程 } }); NSLog(@"syncSerial---end"); }
輸出結果爲:
2018-02-23 20:39:37.876811+0800 YSC-GCD-demo[19975:5017162] currentThread---<NSThread: 0x604000079400>{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---<NSThread: 0x604000079400>{number = 1, name = main}
2018-02-23 20:39:41.879829+0800 YSC-GCD-demo[19975:5017162] 1---<NSThread: 0x604000079400>{number = 1, name = main}
2018-02-23 20:39:43.880660+0800 YSC-GCD-demo[19975:5017162] 2---<NSThread: 0x604000079400>{number = 1, name = main}
2018-02-23 20:39:45.881265+0800 YSC-GCD-demo[19975:5017162] 2---<NSThread: 0x604000079400>{number = 1, name = main}
2018-02-23 20:39:47.882257+0800 YSC-GCD-demo[19975:5017162] 3---<NSThread: 0x604000079400>{number = 1, name = main}
2018-02-23 20:39:49.883008+0800 YSC-GCD-demo[19975:5017162] 3---<NSThread: 0x604000079400>{number = 1, name = main}
2018-02-23 20:39:49.883253+0800 YSC-GCD-demo[19975:5017162] syncSerial---end
在同步執行 + 串行隊列
能夠看到:
同步執行
不具有開啓新線程的能力)。syncConcurrent---begin
和syncConcurrent---end
之間執行(同步任務
須要等待隊列的任務執行結束)。串行隊列
每次只有一個任務被執行,任務一個接一個按順序執行)。/** * 異步執行 + 串行隊列 * 特色:會開啓新線程,可是由於任務是串行的,執行完一個任務,再執行下一個任務。 */ - (void)asyncSerial { NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程 NSLog(@"asyncSerial---begin"); dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL); dispatch_async(queue, ^{ // 追加任務1 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程 } }); dispatch_async(queue, ^{ // 追加任務2 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"2---%@",[NSThread currentThread]); // 打印當前線程 } }); dispatch_async(queue, ^{ // 追加任務3 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"3---%@",[NSThread currentThread]); // 打印當前線程 } }); NSLog(@"asyncSerial---end"); }
輸出結果爲:
2018-02-23 20:41:17.029999+0800 YSC-GCD-demo[20008:5024757] currentThread---<NSThread: 0x604000070440>{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---<NSThread: 0x60000026e100>{number = 3, name = (null)}
2018-02-23 20:41:21.037140+0800 YSC-GCD-demo[20008:5024950] 1---<NSThread: 0x60000026e100>{number = 3, name = (null)}
2018-02-23 20:41:23.042220+0800 YSC-GCD-demo[20008:5024950] 2---<NSThread: 0x60000026e100>{number = 3, name = (null)}
2018-02-23 20:41:25.042971+0800 YSC-GCD-demo[20008:5024950] 2---<NSThread: 0x60000026e100>{number = 3, name = (null)}
2018-02-23 20:41:27.047690+0800 YSC-GCD-demo[20008:5024950] 3---<NSThread: 0x60000026e100>{number = 3, name = (null)}
2018-02-23 20:41:29.052327+0800 YSC-GCD-demo[20008:5024950] 3---<NSThread: 0x60000026e100>{number = 3, name = (null)}
在異步執行 + 串行隊列
能夠看到:
異步執行
具有開啓新線程的能力,串行隊列
只開啓一個線程)。syncConcurrent---begin
和syncConcurrent---end
以後纔開始執行的(異步執行
不會作任何等待,能夠繼續執行任務)。串行隊列
每次只有一個任務被執行,任務一個接一個按順序執行)。下邊講講剛纔咱們提到過的特殊隊列:主隊列。
主隊列:GCD自帶的一種特殊的串行隊列
dispatch_get_main_queue()
得到主隊列咱們再來看看主隊列的兩種組合方式。
同步執行 + 主隊列
在不一樣線程中調用結果也是不同,在主線程中調用會出現死鎖,而在其餘線程中則不會。
同步執行 + 主隊列
/** * 同步執行 + 主隊列 * 特色(主線程調用):互等卡主不執行。 * 特色(其餘線程調用):不會開啓新線程,執行完一個任務,再執行下一個任務。 */ - (void)syncMain { NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程 NSLog(@"syncMain---begin"); dispatch_queue_t queue = dispatch_get_main_queue(); dispatch_sync(queue, ^{ // 追加任務1 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程 } }); dispatch_sync(queue, ^{ // 追加任務2 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"2---%@",[NSThread currentThread]); // 打印當前線程 } }); dispatch_sync(queue, ^{ // 追加任務3 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"3---%@",[NSThread currentThread]); // 打印當前線程 } }); NSLog(@"syncMain---end"); }
輸出結果
2018-02-23 20:42:36.842892+0800 YSC-GCD-demo[20041:5030982] currentThread---<NSThread: 0x600000078a00>{number = 1, name = main}
2018-02-23 20:42:36.843050+0800 YSC-GCD-demo[20041:5030982] syncMain---begin
(lldb)
在同步執行 + 主隊列
能夠驚奇的發現:
同步執行 + 主隊列
,追加到主線程的任務一、任務二、任務3都再也不執行了,並且syncMain---end
也沒有打印,在XCode 9上還會報崩潰。這是爲何呢?這是由於咱們在主線程中執行syncMain
方法,至關於把syncMain
任務放到了主線程的隊列中。而同步執行
會等待當前隊列中的任務執行完畢,纔會接着執行。那麼當咱們把任務1
追加到主隊列中,任務1
就在等待主線程處理完syncMain
任務。而syncMain
任務須要等待任務1
執行完畢,才能接着執行。
那麼,如今的狀況就是syncMain
任務和任務1
都在等對方執行完畢。這樣你們互相等待,因此就卡住了,因此咱們的任務執行不了,並且syncMain---end
也沒有打印。
要是若是不在主線程中調用,而在其餘線程中調用會如何呢?
同步執行 + 主隊列
// 使用 NSThread 的 detachNewThreadSelector 方法會建立線程,並自動啓動線程執行 selector 任務 [NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];
輸出結果:
2018-02-23 20:44:19.377321+0800 YSC-GCD-demo[20083:5040347] currentThread---<NSThread: 0x600000272fc0>{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---<NSThread: 0x60000006c900>{number = 1, name = main}
2018-02-23 20:44:23.386091+0800 YSC-GCD-demo[20083:5040132] 1---<NSThread: 0x60000006c900>{number = 1, name = main}
2018-02-23 20:44:25.387687+0800 YSC-GCD-demo[20083:5040132] 2---<NSThread: 0x60000006c900>{number = 1, name = main}
2018-02-23 20:44:27.388648+0800 YSC-GCD-demo[20083:5040132] 2---<NSThread: 0x60000006c900>{number = 1, name = main}
2018-02-23 20:44:29.390459+0800 YSC-GCD-demo[20083:5040132] 3---<NSThread: 0x60000006c900>{number = 1, name = main}
2018-02-23 20:44:31.391965+0800 YSC-GCD-demo[20083:5040132] 3---<NSThread: 0x60000006c900>{number = 1, name = main}
2018-02-23 20:44:31.392513+0800 YSC-GCD-demo[20083:5040347] syncMain---end
在其餘線程中使用同步執行 + 主隊列
可看到:
主隊列
中的任務,都會放到主線程中執行)。syncConcurrent---begin
和syncConcurrent---end
之間執行(同步任務
須要等待隊列的任務執行結束)。串行隊列
,每次只有一個任務被執行,任務一個接一個按順序執行)。爲何如今就不會卡住了呢?
由於syncMain 任務
放到了其餘線程裏,而任務1
、任務2
、任務3
都在追加到主隊列中,這三個任務都會在主線程中執行。syncMain 任務
在其餘線程中執行到追加任務1
到主隊列中,由於主隊列如今沒有正在執行的任務,因此,會直接執行主隊列的任務1
,等任務1
執行完畢,再接着執行任務2
、任務3
。因此這裏不會卡住線程。
/** * 異步執行 + 主隊列 * 特色:只在主線程中執行任務,執行完一個任務,再執行下一個任務 */ - (void)asyncMain { NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程 NSLog(@"asyncMain---begin"); dispatch_queue_t queue = dispatch_get_main_queue(); dispatch_async(queue, ^{ // 追加任務1 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程 } }); dispatch_async(queue, ^{ // 追加任務2 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"2---%@",[NSThread currentThread]); // 打印當前線程 } }); dispatch_async(queue, ^{ // 追加任務3 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"3---%@",[NSThread currentThread]); // 打印當前線程 } }); NSLog(@"asyncMain---end"); }
輸出結果:
2018-02-23 20:45:49.981505+0800 YSC-GCD-demo[20111:5046708] currentThread---<NSThread: 0x60000006d440>{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---<NSThread: 0x60000006d440>{number = 1, name = main}
2018-02-23 20:45:53.991959+0800 YSC-GCD-demo[20111:5046708] 1---<NSThread: 0x60000006d440>{number = 1, name = main}
2018-02-23 20:45:55.992937+0800 YSC-GCD-demo[20111:5046708] 2---<NSThread: 0x60000006d440>{number = 1, name = main}
2018-02-23 20:45:57.993649+0800 YSC-GCD-demo[20111:5046708] 2---<NSThread: 0x60000006d440>{number = 1, name = main}
2018-02-23 20:45:59.994928+0800 YSC-GCD-demo[20111:5046708] 3---<NSThread: 0x60000006d440>{number = 1, name = main}
2018-02-23 20:46:01.995589+0800 YSC-GCD-demo[20111:5046708] 3---<NSThread: 0x60000006d440>{number = 1, name = main}
在異步執行 + 主隊列
能夠看到:
異步執行
具有開啓線程的能力,但由於是主隊列,因此全部任務都在主線程中)。串行隊列
,每次只有一個任務被執行,任務一個接一個按順序執行)。弄懂了難理解、繞來繞去的隊列+任務以後,咱們來學習一個簡單的東西:5. GCD 線程間的通訊。
在iOS開發過程當中,咱們通常在主線程裏邊進行UI刷新,例如:點擊、滾動、拖拽等事件。咱們一般把一些耗時的操做放在其餘線程,好比說圖片下載、文件上傳等耗時操做。而當咱們有時候在其餘線程完成了耗時操做時,須要回到主線程,那麼就用到了線程之間的通信。
/** * 線程間通訊 */ - (void)communication { // 獲取全局併發隊列 dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); // 獲取主隊列 dispatch_queue_t mainQueue = dispatch_get_main_queue(); dispatch_async(queue, ^{ // 異步追加任務 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程 } // 回到主線程 dispatch_async(mainQueue, ^{ // 追加在主線程中執行的任務 [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"2---%@",[NSThread currentThread]); // 打印當前線程 }); }); }
輸出結果:
2018-02-23 20:47:03.462394+0800 YSC-GCD-demo[20154:5053282] 1---<NSThread: 0x600000271940>{number = 3, name = (null)}
2018-02-23 20:47:05.465912+0800 YSC-GCD-demo[20154:5053282] 1---<NSThread: 0x600000271940>{number = 3, name = (null)}
2018-02-23 20:47:07.466657+0800 YSC-GCD-demo[20154:5052953] 2---<NSThread: 0x60000007bf80>{number = 1, name = main}
柵欄
同樣的一個方法將兩組異步執行的操做組給分割起來,固然這裏的操做組裏能夠包含一個或多個任務。這就須要用到dispatch_barrier_async
方法在兩個操做組間造成柵欄。dispatch_barrier_async
函數會等待前邊追加到併發隊列中的任務所有執行完畢以後,再將指定的任務追加到該異步隊列中。而後在dispatch_barrier_async
函數追加的任務執行完畢以後,異步隊列才恢復爲通常動做,接着追加任務到該異步隊列並開始執行。具體以下圖所示:
/** * 柵欄方法 dispatch_barrier_async */ - (void)barrier { dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT); dispatch_async(queue, ^{ // 追加任務1 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程 } }); dispatch_async(queue, ^{ // 追加任務2 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"2---%@",[NSThread currentThread]); // 打印當前線程 } }); dispatch_barrier_async(queue, ^{ // 追加任務 barrier for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"barrier---%@",[NSThread currentThread]);// 打印當前線程 } }); dispatch_async(queue, ^{ // 追加任務3 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"3---%@",[NSThread currentThread]); // 打印當前線程 } }); dispatch_async(queue, ^{ // 追加任務4 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"4---%@",[NSThread currentThread]); // 打印當前線程 } }); }
輸出結果:
2018-02-23 20:48:18.297745+0800 YSC-GCD-demo[20188:5059274] 1---<NSThread: 0x600000079d80>{number = 4, name = (null)}
2018-02-23 20:48:18.297745+0800 YSC-GCD-demo[20188:5059273] 2---<NSThread: 0x600000079e00>{number = 3, name = (null)}
2018-02-23 20:48:20.301139+0800 YSC-GCD-demo[20188:5059274] 1---<NSThread: 0x600000079d80>{number = 4, name = (null)}
2018-02-23 20:48:20.301139+0800 YSC-GCD-demo[20188:5059273] 2---<NSThread: 0x600000079e00>{number = 3, name = (null)}
2018-02-23 20:48:22.306290+0800 YSC-GCD-demo[20188:5059274] barrier---<NSThread: 0x600000079d80>{number = 4, name = (null)}
2018-02-23 20:48:24.311655+0800 YSC-GCD-demo[20188:5059274] barrier---<NSThread: 0x600000079d80>{number = 4, name = (null)}
2018-02-23 20:48:26.316943+0800 YSC-GCD-demo[20188:5059273] 4---<NSThread: 0x600000079e00>{number = 3, name = (null)}
2018-02-23 20:48:26.316956+0800 YSC-GCD-demo[20188:5059274] 3---<NSThread: 0x600000079d80>{number = 4, name = (null)}
2018-02-23 20:48:28.320660+0800 YSC-GCD-demo[20188:5059273] 4---<NSThread: 0x600000079e00>{number = 3, name = (null)}
2018-02-23 20:48:28.320649+0800 YSC-GCD-demo[20188:5059274] 3---<NSThread: 0x600000079d80>{number = 4, name = (null)}
在dispatch_barrier_async
執行結果中能夠看出:
咱們常常會遇到這樣的需求:在指定時間(例如3秒)以後執行某個任務。能夠用 GCD 的dispatch_after
函數來實現。
須要注意的是:dispatch_after
函數並非在指定時間以後纔開始執行處理,而是在指定時間以後將任務追加到主隊列中。嚴格來講,這個時間並非絕對準確的,但想要大體延遲執行任務,dispatch_after
函數是頗有效的。
/** * 延時執行方法 dispatch_after */ - (void)after { NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程 NSLog(@"asyncMain---begin"); dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{ // 2.0秒後異步追加任務代碼到主隊列,並開始執行 NSLog(@"after---%@",[NSThread currentThread]); // 打印當前線程 }); }
輸出結果:
2018-02-23 20:53:08.713784+0800 YSC-GCD-demo[20282:5080295] currentThread---<NSThread: 0x60000006ee00>{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---<NSThread: 0x60000006ee00>{number = 1, name = main}
能夠看出:在打印 asyncMain---begin
以後大約 2.0 秒的時間,打印了 after---<NSThread: 0x60000006ee00>{number = 1, name = main}
dispatch_once
函數。使用dispatch_once
函數能保證某段代碼在程序運行過程當中只被執行1次,而且即便在多線程的環境下,dispatch_once
也能夠保證線程安全。/** * 一次性代碼(只執行一次)dispatch_once */ - (void)once { static dispatch_once_t onceToken; dispatch_once(&onceToken, ^{ // 只執行1次的代碼(這裏面默認是線程安全的) }); }
dispatch_apply
。dispatch_apply
按照指定的次數將指定的任務追加到指定的隊列中,並等待所有隊列執行結束。若是是在串行隊列中使用 dispatch_apply
,那麼就和 for 循環同樣,按順序同步執行。可這樣就體現不出快速迭代的意義了。
咱們能夠利用併發隊列進行異步執行。好比說遍歷 0~5 這6個數字,for 循環的作法是每次取出一個元素,逐個遍歷。dispatch_apply
能夠 在多個線程中同時(異步)遍歷多個數字。
還有一點,不管是在串行隊列,仍是異步隊列中,dispatch_apply 都會等待所有任務執行完畢,這點就像是同步操做,也像是隊列組中的 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"); }
輸出結果:
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---<NSThread: 0x60000027b8c0>{number = 3, name = (null)}
2018-02-23 22:03:18.476693+0800 YSC-GCD-demo[20470:5176805] 0---<NSThread: 0x604000070640>{number = 1, name = main}
2018-02-23 22:03:18.476704+0800 YSC-GCD-demo[20470:5177037] 2---<NSThread: 0x604000276800>{number = 4, name = (null)}
2018-02-23 22:03:18.476735+0800 YSC-GCD-demo[20470:5177036] 3---<NSThread: 0x60000027b800>{number = 5, name = (null)}
2018-02-23 22:03:18.476867+0800 YSC-GCD-demo[20470:5177035] 4---<NSThread: 0x60000027b8c0>{number = 3, name = (null)}
2018-02-23 22:03:18.476867+0800 YSC-GCD-demo[20470:5176805] 5---<NSThread: 0x604000070640>{number = 1, name = main}
2018-02-23 22:03:18.477038+0800 YSC-GCD-demo[20470:5176805] apply---end
由於是在併發隊列中異步執行任務,因此各個任務的執行時間長短不定,最後結束順序也不定。可是apply---end
必定在最後執行。這是由於dispatch_apply
函數會等待所有任務執行完畢。
有時候咱們會有這樣的需求:分別異步執行2個耗時任務,而後當2個耗時任務都執行完畢後再回到主線程執行任務。這時候咱們能夠用到 GCD 的隊列組。
dispatch_group_async
先把任務放到隊列中,而後將隊列放入隊列組中。或者使用隊列組的 dispatch_group_enter、dispatch_group_leave
組合 來實現dispatch_group_async
。dispatch_group_notify
回到指定線程執行任務。或者使用 dispatch_group_wait
回到當前線程繼續向下執行(會阻塞當前線程)。/** * 隊列組 dispatch_group_notify */ - (void)groupNotify { NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程 NSLog(@"group---begin"); dispatch_group_t group = dispatch_group_create(); dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ // 追加任務1 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程 } }); dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ // 追加任務2 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"2---%@",[NSThread currentThread]); // 打印當前線程 } }); dispatch_group_notify(group, dispatch_get_main_queue(), ^{ // 等前面的異步任務一、任務2都執行完畢後,回到主線程執行下邊任務 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"3---%@",[NSThread currentThread]); // 打印當前線程 } NSLog(@"group---end"); }); }
輸出結果:
2018-02-23 22:05:03.790035+0800 YSC-GCD-demo[20494:5183349] currentThread---<NSThread: 0x604000072040>{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---<NSThread: 0x60000026f280>{number = 4, name = (null)}
2018-02-23 22:05:05.792725+0800 YSC-GCD-demo[20494:5183656] 2---<NSThread: 0x60000026f240>{number = 3, name = (null)}
2018-02-23 22:05:07.797408+0800 YSC-GCD-demo[20494:5183656] 2---<NSThread: 0x60000026f240>{number = 3, name = (null)}
2018-02-23 22:05:07.797408+0800 YSC-GCD-demo[20494:5183654] 1---<NSThread: 0x60000026f280>{number = 4, name = (null)}
2018-02-23 22:05:09.798717+0800 YSC-GCD-demo[20494:5183349] 3---<NSThread: 0x604000072040>{number = 1, name = main}
2018-02-23 22:05:11.799827+0800 YSC-GCD-demo[20494:5183349] 3---<NSThread: 0x604000072040>{number = 1, name = main}
2018-02-23 22:05:11.799977+0800 YSC-GCD-demo[20494:5183349] group---end
從dispatch_group_notify
相關代碼運行輸出結果能夠看出:
當全部任務都執行完成以後,才執行dispatch_group_notify
block 中的任務。
/** * 隊列組 dispatch_group_wait */ - (void)groupWait { NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程 NSLog(@"group---begin"); dispatch_group_t group = dispatch_group_create(); dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ // 追加任務1 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程 } }); dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ // 追加任務2 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"2---%@",[NSThread currentThread]); // 打印當前線程 } }); // 等待上面的任務所有完成後,會往下繼續執行(會阻塞當前線程) dispatch_group_wait(group, DISPATCH_TIME_FOREVER); NSLog(@"group---end"); }
輸出結果:
2018-02-23 22:10:16.939258+0800 YSC-GCD-demo[20538:5198871] currentThread---<NSThread: 0x600000066780>{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---<NSThread: 0x600000464b80>{number = 4, name = (null)}
2018-02-23 22:10:18.943861+0800 YSC-GCD-demo[20538:5199138] 1---<NSThread: 0x604000076640>{number = 3, name = (null)}
2018-02-23 22:10:20.947787+0800 YSC-GCD-demo[20538:5199137] 2---<NSThread: 0x600000464b80>{number = 4, name = (null)}
2018-02-23 22:10:20.947790+0800 YSC-GCD-demo[20538:5199138] 1---<NSThread: 0x604000076640>{number = 3, name = (null)}
2018-02-23 22:10:20.948134+0800 YSC-GCD-demo[20538:5198871] group---end
從dispatch_group_wait
相關代碼運行輸出結果能夠看出:
當全部任務執行完成以後,才執行 dispatch_group_wait
以後的操做。可是,使用dispatch_group_wait
會阻塞當前線程。
dispatch_group_enter
標誌着一個任務追加到 group,執行一次,至關於 group 中未執行完畢任務數+1dispatch_group_leave
標誌着一個任務離開了 group,執行一次,至關於 group 中未執行完畢任務數-1。dispatch_group_wait
解除阻塞,以及執行追加到dispatch_group_notify
中的任務。/** * 隊列組 dispatch_group_enter、dispatch_group_leave */ - (void)groupEnterAndLeave { NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程 NSLog(@"group---begin"); dispatch_group_t group = dispatch_group_create(); dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); dispatch_group_enter(group); dispatch_async(queue, ^{ // 追加任務1 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程 } dispatch_group_leave(group); }); dispatch_group_enter(group); dispatch_async(queue, ^{ // 追加任務2 for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"2---%@",[NSThread currentThread]); // 打印當前線程 } dispatch_group_leave(group); }); dispatch_group_notify(group, dispatch_get_main_queue(), ^{ // 等前面的異步操做都執行完畢後,回到主線程. for (int i = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"3---%@",[NSThread currentThread]); // 打印當前線程 } NSLog(@"group---end"); }); // // 等待上面的任務所有完成後,會往下繼續執行(會阻塞當前線程) // dispatch_group_wait(group, DISPATCH_TIME_FOREVER); // // NSLog(@"group---end"); }
輸出結果:
2018-02-23 22:14:17.997667+0800 YSC-GCD-demo[20592:5214830] currentThread---<NSThread: 0x604000066600>{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---<NSThread: 0x600000277c80>{number = 4, name = (null)}
2018-02-23 22:14:20.000305+0800 YSC-GCD-demo[20592:5215095] 2---<NSThread: 0x600000277c40>{number = 3, name = (null)}
2018-02-23 22:14:22.001323+0800 YSC-GCD-demo[20592:5215094] 1---<NSThread: 0x600000277c80>{number = 4, name = (null)}
2018-02-23 22:14:22.001339+0800 YSC-GCD-demo[20592:5215095] 2---<NSThread: 0x600000277c40>{number = 3, name = (null)}
2018-02-23 22:14:24.002321+0800 YSC-GCD-demo[20592:5214830] 3---<NSThread: 0x604000066600>{number = 1, name = main}
2018-02-23 22:14:26.002852+0800 YSC-GCD-demo[20592:5214830] 3---<NSThread: 0x604000066600>{number = 1, name = main}
2018-02-23 22:14:26.003116+0800 YSC-GCD-demo[20592:5214830] group---end
從dispatch_group_enter、dispatch_group_leave
相關代碼運行結果中能夠看出:當全部任務執行完成以後,才執行 dispatch_group_notify 中的任務。這裏的dispatch_group_enter、dispatch_group_leave
組合,其實等同於dispatch_group_async
。
GCD 中的信號量是指 Dispatch Semaphore,是持有計數的信號。相似於太高速路收費站的欄杆。能夠經過時,打開欄杆,不能夠經過時,關閉欄杆。在 Dispatch Semaphore 中,使用計數來完成這個功能,計數爲0時等待,不可經過。計數爲1或大於1時,計數減1且不等待,可經過。
Dispatch Semaphore 提供了三個函數。
dispatch_semaphore_create
:建立一個Semaphore並初始化信號的總量dispatch_semaphore_signal
:發送一個信號,讓信號總量加1dispatch_semaphore_wait
:可使總信號量減1,當信號總量爲0時就會一直等待(阻塞所在線程),不然就能夠正常執行。注意:信號量的使用前提是:想清楚你須要處理哪一個線程等待(阻塞),又要哪一個線程繼續執行,而後使用信號量。
Dispatch Semaphore 在實際開發中主要用於:
咱們在開發中,會遇到這樣的需求:異步執行耗時任務,並使用異步執行的結果進行一些額外的操做。換句話說,至關於,將將異步執行任務轉換爲同步執行任務。好比說:AFNetworking 中 AFURLSessionManager.m 裏面的 tasksForKeyPath:
方法。經過引入信號量的方式,等待異步執行任務結果,獲取到 tasks,而後再返回該 tasks。
- (NSArray *)tasksForKeyPath:(NSString *)keyPath { __block NSArray *tasks = nil; dispatch_semaphore_t semaphore = dispatch_semaphore_create(0); [self.session getTasksWithCompletionHandler:^(NSArray *dataTasks, NSArray *uploadTasks, NSArray *downloadTasks) { if ([keyPath isEqualToString:NSStringFromSelector(@selector(dataTasks))]) { tasks = dataTasks; } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(uploadTasks))]) { tasks = uploadTasks; } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(downloadTasks))]) { tasks = downloadTasks; } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(tasks))]) { tasks = [@[dataTasks, uploadTasks, downloadTasks] valueForKeyPath:@"@unionOfArrays.self"]; } dispatch_semaphore_signal(semaphore); }]; dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER); return tasks; }
下面,咱們來利用 Dispatch Semaphore 實現線程同步,將異步執行任務轉換爲同步執行任務。
/** * semaphore 線程同步 */ - (void)semaphoreSync { NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程 NSLog(@"semaphore---begin"); dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); dispatch_semaphore_t semaphore = dispatch_semaphore_create(0); __block int number = 0; dispatch_async(queue, ^{ // 追加任務1 [NSThread sleepForTimeInterval:2]; // 模擬耗時操做 NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程 number = 100; dispatch_semaphore_signal(semaphore); }); dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER); NSLog(@"semaphore---end,number = %zd",number); }
輸出結果:
2018-02-23 22:22:26.521665+0800 YSC-GCD-demo[20642:5246341] currentThread---<NSThread: 0x60400006bc80>{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---<NSThread: 0x600000272300>{number = 3, name = (null)}
2018-02-23 22:22:28.527030+0800 YSC-GCD-demo[20642:5246341] semaphore---end,number = 100
從 Dispatch Semaphore 實現線程同步的代碼能夠看到:
semaphore---end
是在執行完 number = 100;
以後纔打印的。並且輸出結果 number 爲 100。這是由於異步執行
不會作任何等待,能夠繼續執行任務。異步執行
將任務1追加到隊列以後,不作等待,接着執行dispatch_semaphore_wait
方法。此時 semaphore == 0,當前線程進入等待狀態。而後,異步任務1開始執行。任務1執行到dispatch_semaphore_signal
以後,總信號量,此時 semaphore == 1,dispatch_semaphore_wait
方法使總信號量減1,正在被阻塞的線程(主線程)恢復繼續執行。最後打印semaphore---end,number = 100
。這樣就實現了線程同步,將異步執行任務轉換爲同步執行任務。
線程安全:若是你的代碼所在的進程中有多個線程在同時運行,而這些線程可能會同時運行這段代碼。若是每次運行結果和單線程運行的結果是同樣的,並且其餘的變量的值也和預期的是同樣的,就是線程安全的。
若每一個線程中對全局變量、靜態變量只有讀操做,而無寫操做,通常來講,這個全局變量是線程安全的;如有多個線程同時執行寫操做(更改變量),通常都須要考慮線程同步,不然的話就可能影響線程安全。
線程同步:可理解爲線程 A 和 線程 B 一塊配合,A 執行到必定程度時要依靠線程 B 的某個結果,因而停下來,示意 B 運行;B 依言執行,再將結果給 A;A 再繼續操做。
舉個簡單例子就是:兩我的在一塊兒聊天。兩我的不能同時說話,避免聽不清(操做衝突)。等一我的說完(一個線程結束操做),另外一個再說(另外一個線程再開始操做)。
下面,咱們模擬火車票售賣的方式,實現 NSThread 線程安全和解決線程同步問題。
場景:總共有50張火車票,有兩個售賣火車票的窗口,一個是北京火車票售賣窗口,另外一個是上海火車票售賣窗口。兩個窗口同時售賣火車票,賣完爲止。
先來看看不考慮線程安全的代碼:
/** * 非線程安全:不使用 semaphore * 初始化火車票數量、賣票窗口(非線程安全)、並開始賣票 */ - (void)initTicketStatusNotSave { NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程 NSLog(@"semaphore---begin"); self.ticketSurplusCount = 50; // queue1 表明北京火車票售賣窗口 dispatch_queue_t queue1 = dispatch_queue_create("net.bujige.testQueue1", DISPATCH_QUEUE_SERIAL); // queue2 表明上海火車票售賣窗口 dispatch_queue_t queue2 = dispatch_queue_create("net.bujige.testQueue2", DISPATCH_QUEUE_SERIAL); __weak typeof(self) weakSelf = self; dispatch_async(queue1, ^{ [weakSelf saleTicketNotSafe]; }); dispatch_async(queue2, ^{ [weakSelf saleTicketNotSafe]; }); } /** * 售賣火車票(非線程安全) */ - (void)saleTicketNotSafe { while (1) { if (self.ticketSurplusCount > 0) { //若是還有票,繼續售賣 self.ticketSurplusCount--; NSLog(@"%@", [NSString stringWithFormat:@"剩餘票數:%d 窗口:%@", self.ticketSurplusCount, [NSThread currentThread]]); [NSThread sleepForTimeInterval:0.2]; } else { //若是已賣完,關閉售票窗口 NSLog(@"全部火車票均已售完"); break; } } }
輸出結果(部分):
2018-02-23 22:25:35.789072+0800 YSC-GCD-demo[20712:5258914] currentThread---<NSThread: 0x604000068880>{number = 1, name = main}
2018-02-23 22:25:35.789260+0800 YSC-GCD-demo[20712:5258914] semaphore---begin
2018-02-23 22:25:35.789641+0800 YSC-GCD-demo[20712:5259176] 剩餘票數:48 窗口:<NSThread: 0x60000027db80>{number = 3, name = (null)}
2018-02-23 22:25:35.789646+0800 YSC-GCD-demo[20712:5259175] 剩餘票數:49 窗口:<NSThread: 0x60000027e740>{number = 4, name = (null)}
2018-02-23 22:25:35.994113+0800 YSC-GCD-demo[20712:5259175] 剩餘票數:47 窗口:<NSThread: 0x60000027e740>{number = 4, name = (null)}
2018-02-23 22:25:35.994129+0800 YSC-GCD-demo[20712:5259176] 剩餘票數:46 窗口:<NSThread: 0x60000027db80>{number = 3, name = (null)}
2018-02-23 22:25:36.198993+0800 YSC-GCD-demo[20712:5259176] 剩餘票數:45 窗口:<NSThread: 0x60000027db80>{number = 3, name = (null)}
...
能夠看到在不考慮線程安全,不使用 semaphore 的狀況下,獲得票數是錯亂的,這樣顯然不符合咱們的需求,因此咱們須要考慮線程安全問題。
考慮線程安全的代碼:
/** * 線程安全:使用 semaphore 加鎖 * 初始化火車票數量、賣票窗口(線程安全)、並開始賣票 */ - (void)initTicketStatusSave { NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程 NSLog(@"semaphore---begin"); semaphoreLock = dispatch_semaphore_create(1); self.ticketSurplusCount = 50; // queue1 表明北京火車票售賣窗口 dispatch_queue_t queue1 = dispatch_queue_create("net.bujige.testQueue1", DISPATCH_QUEUE_SERIAL); // queue2 表明上海火車票售賣窗口 dispatch_queue_t queue2 = dispatch_queue_create("net.bujige.testQueue2", DISPATCH_QUEUE_SERIAL); __weak typeof(self) weakSelf = self; dispatch_async(queue1, ^{ [weakSelf saleTicketSafe]; }); dispatch_async(queue2, ^{ [weakSelf saleTicketSafe]; }); } /** * 售賣火車票(線程安全) */ - (void)saleTicketSafe { while (1) { // 至關於加鎖 dispatch_semaphore_wait(semaphoreLock, DISPATCH_TIME_FOREVER); if (self.ticketSurplusCount > 0) { //若是還有票,繼續售賣 self.ticketSurplusCount--; NSLog(@"%@", [NSString stringWithFormat:@"剩餘票數:%d 窗口:%@", self.ticketSurplusCount, [NSThread currentThread]]); [NSThread sleepForTimeInterval:0.2]; } else { //若是已賣完,關閉售票窗口 NSLog(@"全部火車票均已售完"); // 至關於解鎖 dispatch_semaphore_signal(semaphoreLock); break; } // 至關於解鎖 dispatch_semaphore_signal(semaphoreLock); } }
輸出結果爲:
2018-02-23 22:32:19.814232+0800 YSC-GCD-demo[20862:5290531] currentThread---<NSThread: 0x6000000783c0>{number = 1, name = main}
2018-02-23 22:32:19.814412+0800 YSC-GCD-demo[20862:5290531] semaphore---begin
2018-02-23 22:32:19.814837+0800 YSC-GCD-demo[20862:5290687] 剩餘票數:49 窗口:<NSThread: 0x6040002709c0>{number = 3, name = (null)}
2018-02-23 22:32:20.017745+0800 YSC-GCD-demo[20862:5290689] 剩餘票數:48 窗口:<NSThread: 0x60000046c640>{number = 4, name = (null)}
2018-02-23 22:32:20.222039+0800 YSC-GCD-demo[20862:5290687] 剩餘票數:47 窗口:<NSThread: 0x6040002709c0>{number = 3, name = (null)}
...
2018-02-23 22:32:29.024817+0800 YSC-GCD-demo[20862:5290689] 剩餘票數:4 窗口:<NSThread: 0x60000046c640>{number = 4, name = (null)}
2018-02-23 22:32:29.230110+0800 YSC-GCD-demo[20862:5290687] 剩餘票數:3 窗口:<NSThread: 0x6040002709c0>{number = 3, name = (null)}
2018-02-23 22:32:29.433615+0800 YSC-GCD-demo[20862:5290689] 剩餘票數:2 窗口:<NSThread: 0x60000046c640>{number = 4, name = (null)}
2018-02-23 22:32:29.637572+0800 YSC-GCD-demo[20862:5290687] 剩餘票數:1 窗口:<NSThread: 0x6040002709c0>{number = 3, name = (null)}
2018-02-23 22:32:29.840234+0800 YSC-GCD-demo[20862:5290689] 剩餘票數:0 窗口:<NSThread: 0x60000046c640>{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
參考資料: