c语言gcd 简易函数,简单[GCD]用法详细总结(上)
原文鏈接：https://www.jianshu.com/p/2d57c72016c6
本文用來介紹 iOS 多線程中 GCD 的相關知識以及使用方法。通過本文，您將了解到：
1. GCD 簡介
2. GCD 任務和隊列
3. GCD 的使用步驟
4. GCD 的基本使用(6種不同組合區別)
1. GCD 簡介
什么是 GCD 呢？我們先來看看百度百科的解釋簡單了解下概念Grand Central Dispatch(GCD)是 Apple 開發的一個多核編程的較新的解決方法。它主要用于優化應用程序以支持多核處理器以及其他對稱多處理系統。它是一個在線程池模式的基礎上執行的并發任務。在 Mac OS X 10.6 雪豹中首次推出，也可在 iOS 4 及以上版本使用。
為什么要用 GCD 呢？
因為 GCD 有很多好處啊，具體如下：GCD 可用于多核的并行運算
GCD 會自動利用更多的 CPU 內核(比如雙核、四核)
GCD 會自動管理線程的生命周期(創建線程、調度任務、銷毀線程)
程序員只需要告訴 GCD 想要執行什么任務，不需要編寫任何線程管理代碼
既然 GCD 有這么多的好處，那么下面我們就來系統的學習一下 GCD 的使用方法。
2. GCD 任務和隊列
學習 GCD 之前，先來了解 GCD 中兩個核心概念：任務和隊列。
任務：就是執行操作的意思，換句話說就是你在線程中執行的那段代碼。在 GCD 中是放在 block 中的。執行任務有兩種方式：同步執行(sync)和異步執行(async)。兩者的主要區別是：是否等待隊列的任務執行結束，以及是否具備開啟新線程的能力。
同步執行(sync)：
同步添加任務到指定的隊列中，在添加的任務執行結束之前，會一直等待，直到隊列里面的任務完成之后再繼續執行。
只能在當前線程中執行任務，不具備開啟新線程的能力。
異步執行(async)：
異步添加任務到指定的隊列中，它不會做任何等待，可以繼續執行任務。
可以在新的線程中執行任務，具備開啟新線程的能力。
舉個簡單例子：你要打電話給小明和小白。
同步執行就是，你打電話給小明的時候，不能同時打給小白，等到給小明打完了，才能打給小白(等待任務執行結束)。而且只能用當前的電話(不具備開啟新線程的能力)。
而異步執行就是，你打電話給小明的時候，不等和小明通話結束，還能直接給小白打電話，不用等著和小明通話結束再打(不用等待任務執行結束)。除了當前電話，你還可以使用其他所能使用的電話(具備開啟新線程的能力)。
注意：異步執行(async)雖然具有開啟新線程的能力，但是并不一定開啟新線程。這跟任務所指定的隊列類型有關(下面會講)。
隊列(Dispatch Queue)：這里的隊列指執行任務的等待隊列，即用來存放任務的隊列。隊列是一種特殊的線性表，采用 FIFO(先進先出)的原則，即新任務總是被插入到隊列的末尾，而讀取任務的時候總是從隊列的頭部開始讀取。每讀取一個任務，則從隊列中釋放一個任務。隊列的結構可參考下圖：
Serial串行隊列.png
在 GCD 中有兩種隊列：串行隊列和并發隊列。兩者都符合 FIFO(先進先出)的原則。兩者的主要區別是：執行順序不同，以及開啟線程數不同。
串行隊列(Serial Dispatch Queue)：
每次只有一個任務被執行。讓任務一個接著一個地執行。(只開啟一個線程，一個任務執行完畢后，再執行下一個任務)
并發隊列(Concurrent Dispatch Queue)：
可以讓多個任務并發(同時)執行。(可以開啟多個線程，并且同時執行任務)注意：并發隊列的并發功能只有在異步(dispatch_async)函數下才有效
兩者具體區別如下兩圖所示。
串行隊列.png
并發隊列.png
3. GCD 的使用步驟
GCD 的使用步驟其實很簡單，只有兩步。
1.創建一個隊列(串行隊列或并發隊列)
2.將任務追加到任務的等待隊列中，然后系統就會根據任務類型執行任務(同步執行或異步執行)
下邊來看看隊列的創建方法/獲取方法，以及任務的創建方法。
3.1 隊列的創建方法/獲取方法
可以使用dispatch_queue_create來創建隊列，需要傳入兩個參數，第一個參數表示隊列的唯一標識符，用于 DEBUG，可為空，Dispatch Queue 的名稱推薦使用應用程序 ID 這種逆序全程域名；第二個參數用來識別是串行隊列還是并發隊列。DISPATCH_QUEUE_SERIAL表示串行隊列，DISPATCH_QUEUE_CONCURRENT表示并發隊列。// 串行隊列的創建方法dispatch_queue_tqueue= dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
// 并發隊列的創建方法dispatch_queue_tqueue= dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
對于串行隊列，GCD 提供了的一種特殊的串行隊列：主隊列(Main Dispatch Queue)。
a.所有放在主隊列中的任務，都會放到主線程中執行。
b.可使用dispatch_get_main_queue()獲得主隊列。// 主隊列的獲取方法
dispatch_queue_t queue= dispatch_get_main_queue();
對于并發隊列，GCD 默認提供了全局并發隊列(Global Dispatch Queue)。
a.可以使用dispatch_get_global_queue來獲取。需要傳入兩個參數。第一個參數表示隊列優先級，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二個參數暫時沒用，用0即可。// 全局并發隊列的獲取方法
dispatch_queue_tqueue= dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);
3.2 任務的創建方法
GCD 提供了同步執行任務的創建方法dispatch_sync和異步執行任務創建方法dispatch_async。// 同步執行任務創建方法
dispatch_sync(queue, ^{// 這里放同步執行任務代碼});
// 異步執行任務創建方法
dispatch_async(queue, ^{// 這里放異步執行任務代碼});
雖然使用 GCD 只需兩步，但是既然我們有兩種隊列(串行隊列/并發隊列)，兩種任務執行方式(同步執行/異步執行)，那么我們就有了四種不同的組合方式。這四種不同的組合方式是：同步執行 + 并發隊列
異步執行 + 并發隊列
同步執行 + 串行隊列
異步執行 + 串行隊列
實際上，剛才還說了兩種特殊隊列：全局并發隊列、主隊列。全局并發隊列可以作為普通并發隊列來使用。但是主隊列因為有點特殊，所以我們就又多了兩種組合方式。這樣就有六種不同的組合方式了。同步執行 + 主隊列
異步執行 + 主隊列
那么這幾種不同組合方式各有什么區別呢，這里為了方便，先上結果，再來講解。你可以直接查看表格結果，然后跳過4. GCD的基本使用。
下邊我們來分別講講這幾種不同的組合方式的使用方法。
4. GCD 的基本使用
先來講講并發隊列的兩種執行方式。
4.1 同步執行 + 并發隊列
在當前線程中執行任務，不會開啟新線程，執行完一個任務，再執行下一個任務。/**
* 同步執行 + 并發隊列
* 特點：在當前線程中執行任務，不會開啟新線程，執行完一個任務，再執行下一個任務。
*/
- (void)syncConcurrent {
NSLog(@"currentThread---%@",[NSThreadcurrentThread]);
// 打印當前線程NSLog(@"syncConcurrent---begin");
dispatch_queue_tqueue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_sync(queue, ^{
// 追加任務1
for(inti =0; i <2; ++i) {
[NSThreadsleepForTimeInterval:2];// 模擬耗時操作
NSLog(@"1---%@",[NSThreadcurrentThread]);// 打印當前線程
}
});
dispatch_sync(queue, ^{
// 追加任務2
for(inti =0; i <2; ++i) {
[NSThreadsleepForTimeInterval:2];// 模擬耗時操作
NSLog(@"2---%@",[NSThreadcurrentThread]);// 打印當前線程
}
});
dispatch_sync(queue, ^{
// 追加任務3
for(inti =0; i <2; ++i) {
[NSThreadsleepForTimeInterval:2];// 模擬耗時操作
NSLog(@"3---%@",[NSThreadcurrentThread]);// 打印當前線程
}
});
NSLog(@"syncConcurrent---end");}輸出結果：
2018-02-23 20:34:55.095932+0800 YSC-GCD-demo[19892:4996930] currentThread---{number = 1, name = main}
2018-02-23 20:34:55.096086+0800 YSC-GCD-demo[19892:4996930] syncConcurrent---begin
2018-02-23 20:34:57.097589+0800 YSC-GCD-demo[19892:4996930] 1---{number = 1, name = main}
2018-02-23 20:34:59.099100+0800 YSC-GCD-demo[19892:4996930] 1---{number = 1, name = main}
2018-02-23 20:35:01.099843+0800 YSC-GCD-demo[19892:4996930] 2---{number = 1, name = main}
2018-02-23 20:35:03.101171+0800 YSC-GCD-demo[19892:4996930] 2---{number = 1, name = main}
2018-02-23 20:35:05.101750+0800 YSC-GCD-demo[19892:4996930] 3---{number = 1, name = main}
2018-02-23 20:35:07.102414+0800 YSC-GCD-demo[19892:4996930] 3---{number = 1, name = main}
2018-02-23 20:35:07.102575+0800 YSC-GCD-demo[19892:4996930] syncConcurrent---end
從同步執行 + 并發隊列中可看到：
a.所有任務都是在當前線程(主線程)中執行的，沒有開啟新的線程(同步執行不具備開啟新線程的能力)。
b.所有任務都在打印的syncConcurrent---begin和syncConcurrent---end之間執行的(同步任務需要等待隊列的任務執行結束)。
任務按順序執行的。按順序執行的原因：雖然并發隊列可以開啟多個線程，并且同時執行多個任務。但是因為本身不能創建新線程，只有當前線程這一個線程(同步任務不具備開啟新線程的能力)，所以也就不存在并發。而且當前線程只有等待當前隊列中正在執行的任務執行完畢之后，才能繼續接著執行下面的操作(同步任務需要等待隊列的任務執行結束)。所以任務只能一個接一個按順序執行，不能同時被執行。
4.2 異步執行 + 并發隊列
可以開啟多個線程，任務交替(同時)執行。/**
* 異步執行 + 并發隊列
* 特點：可以開啟多個線程，任務交替(同時)執行。
*/- (void)asyncConcurrent {
NSLog(@"currentThread---%@",[NSThreadcurrentThread]);
// 打印當前線程NSLog(@"asyncConcurrent---begin");
dispatch_queue_tqueue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
// 追加任務1for(inti =0; i <2; ++i) {
[NSThreadsleepForTimeInterval:2];// 模擬耗時操作
NSLog(@"1---%@",[NSThreadcurrentThread]);// 打印當前線程}
});
dispatch_async(queue, ^{
// 追加任務2
for(inti =0; i <2; ++i) {
[NSThreadsleepForTimeInterval:2];// 模擬耗時操作
NSLog(@"2---%@",[NSThreadcurrentThread]);// 打印當前線程
}
});
dispatch_async(queue, ^{
// 追加任務3
for(inti =0; i <2; ++i) {
[NSThreadsleepForTimeInterval:2];// 模擬耗時操作
NSLog(@"3---%@",[NSThreadcurrentThread]);// 打印當前線程
}
});
NSLog(@"asyncConcurrent---end");}輸出結果：
2018-02-23 20:36:41.769269+0800 YSC-GCD-demo[19929:5005237] currentThread---{number = 1, name = main}
2018-02-23 20:36:41.769496+0800 YSC-GCD-demo[19929:5005237] asyncConcurrent---begin
2018-02-23 20:36:41.769725+0800 YSC-GCD-demo[19929:5005237] asyncConcurrent---end
2018-02-23 20:36:43.774442+0800 YSC-GCD-demo[19929:5005566] 2---{number = 5, name = (null)}
2018-02-23 20:36:43.774440+0800 YSC-GCD-demo[19929:5005567] 3---{number = 4, name = (null)}
2018-02-23 20:36:43.774440+0800 YSC-GCD-demo[19929:5005565] 1---{number = 3, name = (null)}
2018-02-23 20:36:45.779286+0800 YSC-GCD-demo[19929:5005567] 3---{number = 4, name = (null)}
2018-02-23 20:36:45.779302+0800 YSC-GCD-demo[19929:5005565] 1---{number = 3, name = (null)}
2018-02-23 20:36:45.779286+0800 YSC-GCD-demo[19929:5005566] 2---{number = 5, name = (null)}
在異步執行 + 并發隊列中可以看出：
a.除了當前線程(主線程)，系統又開啟了3個線程，并且任務是交替/同時執行的。(異步執行具備開啟新線程的能力。且并發隊列可開啟多個線程，同時執行多個任務)。
b.所有任務是在打印的syncConcurrent---begin和syncConcurrent---end之后才執行的。說明當前線程沒有等待，而是直接開啟了新線程，在新線程中執行任務(異步執行不做等待，可以繼續執行任務)。
接下來再來講講串行隊列的兩種執行方式。
4.3 同步執行 + 串行隊列
不會開啟新線程，在當前線程執行任務。任務是串行的，執行完一個任務，再執行下一個任務。/**
* 同步執行 + 串行隊列
* 特點：不會開啟新線程，在當前線程執行任務。任務是串行的，執行完一個任務，再執行下一個任務。
*/
- (void)syncSerial {
NSLog(@"currentThread---%@",[NSThreadcurrentThread]);// 打印當前線程
NSLog(@"syncSerial---begin");
dispatch_queue_tqueue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
dispatch_sync(queue, ^{
// 追加任務1
for(inti =0; i <2; ++i) {
[NSThreadsleepForTimeInterval:2];// 模擬耗時操作
NSLog(@"1---%@",[NSThreadcurrentThread]);// 打印當前線程
}
});
dispatch_sync(queue, ^{
// 追加任務2
for(inti =0; i <2; ++i) {
[NSThreadsleepForTimeInterval:2];// 模擬耗時操作
NSLog(@"2---%@",[NSThreadcurrentThread]);// 打印當前線程
}
});
dispatch_sync(queue, ^{
// 追加任務3
for(inti =0; i <2; ++i) {
[NSThreadsleepForTimeInterval:2];// 模擬耗時操作
NSLog(@"3---%@",[NSThreadcurrentThread]);// 打印當前線程
}
});
NSLog(@"syncSerial---end");}輸出結果為：
2018-02-23 20:39:37.876811+0800 YSC-GCD-demo[19975:5017162] currentThread---{number = 1, name = main}
2018-02-23 20:39:37.876998+0800 YSC-GCD-demo[19975:5017162] syncSerial---begin
2018-02-23 20:39:39.878316+0800 YSC-GCD-demo[19975:5017162] 1---{number = 1, name = main}
2018-02-23 20:39:41.879829+0800 YSC-GCD-demo[19975:5017162] 1---{number = 1, name = main}
2018-02-23 20:39:43.880660+0800 YSC-GCD-demo[19975:5017162] 2---{number = 1, name = main}
2018-02-23 20:39:45.881265+0800 YSC-GCD-demo[19975:5017162] 2---{number = 1, name = main}
2018-02-23 20:39:47.882257+0800 YSC-GCD-demo[19975:5017162] 3---{number = 1, name = main}
2018-02-23 20:39:49.883008+0800 YSC-GCD-demo[19975:5017162] 3---{number = 1, name = main}
2018-02-23 20:39:49.883253+0800 YSC-GCD-demo[19975:5017162] syncSerial---end
在同步執行 + 串行隊列可以看到：
a.所有任務都是在當前線程(主線程)中執行的，并沒有開啟新的線程(同步執行不具備開啟新線程的能力)。
b.所有任務都在打印的syncConcurrent---begin和syncConcurrent---end之間執行(同步任務需要等待隊列的任務執行結束)。
c.任務是按順序執行的(串行隊列每次只有一個任務被執行，任務一個接一個按順序執行)。
4.4 異步執行 + 串行隊列
會開啟新線程，但是因為任務是串行的，執行完一個任務，再執行下一個任務/**
* 異步執行 + 串行隊列
* 特點：會開啟新線程，但是因為任務是串行的，執行完一個任務，再執行下一個任務。
*/
- (void)asyncSerial {
NSLog(@"currentThread---%@",[NSThreadcurrentThread]);// 打印當前線程
NSLog(@"asyncSerial---begin");
dispatch_queue_tqueue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{
// 追加任務1
for(inti =0; i <2; ++i) {
[NSThreadsleepForTimeInterval:2];// 模擬耗時操作
NSLog(@"1---%@",[NSThreadcurrentThread]);// 打印當前線程
}
});
dispatch_async(queue, ^{
// 追加任務2
for(int i =0; i <2; ++i) {
[NSThreadsleepForTimeInterval:2];// 模擬耗時操作
NSLog(@"2---%@",[NSThreadcurrentThread]);// 打印當前線程
}
});
dispatch_async(queue, ^{
// 追加任務3
for(int i =0; i <2; ++i) {
[NSThreadsleepForTimeInterval:2];// 模擬耗時操作
NSLog(@"3---%@",[NSThreadcurrentThread]);// 打印當前線程
}
});
NSLog(@"asyncSerial---end");}輸出結果為：
2018-02-23 20:41:17.029999+0800 YSC-GCD-demo[20008:5024757] currentThread---{number = 1, name = main}
2018-02-23 20:41:17.030212+0800 YSC-GCD-demo[20008:5024757] asyncSerial---begin
2018-02-23 20:41:17.030364+0800 YSC-GCD-demo[20008:5024757] asyncSerial---end
2018-02-23 20:41:19.035379+0800 YSC-GCD-demo[20008:5024950] 1---{number = 3, name = (null)}
2018-02-23 20:41:21.037140+0800 YSC-GCD-demo[20008:5024950] 1---{number = 3, name = (null)}
2018-02-23 20:41:23.042220+0800 YSC-GCD-demo[20008:5024950] 2---{number = 3, name = (null)}
2018-02-23 20:41:25.042971+0800 YSC-GCD-demo[20008:5024950] 2---{number = 3, name = (null)}
2018-02-23 20:41:27.047690+0800 YSC-GCD-demo[20008:5024950] 3---{number = 3, name = (null)}
2018-02-23 20:41:29.052327+0800 YSC-GCD-demo[20008:5024950] 3---{number = 3, name = (null)}
在異步執行 + 串行隊列可以看到：
a.開啟了一條新線程(異步執行具備開啟新線程的能力，串行隊列只開啟一個線程)。
b.所有任務是在打印的syncConcurrent---begin和syncConcurrent---end之后才開始執行的(異步執行不會做任何等待，可以繼續執行任務)。
c.任務是按順序執行的(串行隊列每次只有一個任務被執行，任務一個接一個按順序執行)。
下邊講講剛才我們提到過的特殊隊列：主隊列。
主隊列：GCD自帶的一種特殊的串行隊列
所有放在主隊列中的任務，都會放到主線程中執行
可使用dispatch_get_main_queue()獲得主隊列
我們再來看看主隊列的兩種組合方式。
4.5 同步執行 + 主隊列
同步執行 + 主隊列在不同線程中調用結果也是不一樣，在主線程中調用會出現死鎖，而在其他線程中則不會。
4.5.1 在主線程中調用同步執行 + 主隊列
互相等待卡住不可行/**
* 同步執行 + 主隊列
* 特點(主線程調用)：互等卡主不執行。
* 特點(其他線程調用)：不會開啟新線程，執行完一個任務，再執行下一個任務。
*/
- (void)syncMain {
NSLog(@"currentThread---%@",[NSThreadcurrentThread]);
// 打印當前線程
NSLog(@"syncMain---begin");
dispatch_queue_tqueue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
// 追加任務1
for(inti =0; i <2; ++i) {
[NSThreadsleepForTimeInterval:2];// 模擬耗時操作
NSLog(@"1---%@",[NSThreadcurrentThread]);// 打印當前線程
}
});
dispatch_sync(queue, ^{
// 追加任務2
for(inti =0; i <2; ++i) {
[NSThreadsleepForTimeInterval:2];// 模擬耗時操作
NSLog(@"2---%@",[NSThreadcurrentThread]);// 打印當前線程
}
});
dispatch_sync(queue, ^{
// 追加任務3
for(inti =0; i <2; ++i) {
[NSThreadsleepForTimeInterval:2];// 模擬耗時操作
NSLog(@"3---%@",[NSThreadcurrentThread]);// 打印當前線程
}
});
NSLog(@"syncMain---end");}輸出結果
2018-02-23 20:42:36.842892+0800 YSC-GCD-demo[20041:5030982] currentThread---{number = 1, name = main}
2018-02-23 20:42:36.843050+0800 YSC-GCD-demo[20041:5030982] syncMain---begin
(lldb)
在同步執行 + 主隊列可以驚奇的發現：
在主線程中使用同步執行 + 主隊列，追加到主線程的任務1、任務2、任務3都不再執行了，而且syncMain---end也沒有打印，在XCode 9上還會報崩潰。這是為什么呢？
這是因為我們在主線程中執行syncMain方法，相當于把syncMain任務放到了主線程的隊列中。而同步執行會等待當前隊列中的任務執行完畢，才會接著執行。那么當我們把任務1追加到主隊列中，任務1就在等待主線程處理完syncMain任務。而syncMain任務需要等待任務1執行完畢，才能接著執行。
那么，現在的情況就是syncMain任務和任務1都在等對方執行完畢。這樣大家互相等待，所以就卡住了，所以我們的任務執行不了，而且syncMain---end也沒有打印。
要是如果不在主線程中調用，而在其他線程中調用會如何呢？
4.5.2 在其他線程中調用同步執行 + 主隊列
不會開啟新線程，執行完一個任務，再執行下一個任務// 使用 NSThread 的 detachNewThreadSelector 方法會創建線程，并自動啟動線程執行selector 任務[NSThread detachNewThreadSelector:@selector(syncMain) toTarget:selfwithObject:nil];輸出結果：
2018-02-23 20:44:19.377321+0800 YSC-GCD-demo[20083:5040347] currentThread---{number = 3, name = (null)}
2018-02-23 20:44:19.377494+0800 YSC-GCD-demo[20083:5040347] syncMain---begin
2018-02-23 20:44:21.384716+0800 YSC-GCD-demo[20083:5040132] 1---{number = 1, name = main}
2018-02-23 20:44:23.386091+0800 YSC-GCD-demo[20083:5040132] 1---{number = 1, name = main}
2018-02-23 20:44:25.387687+0800 YSC-GCD-demo[20083:5040132] 2---{number = 1, name = main}
2018-02-23 20:44:27.388648+0800 YSC-GCD-demo[20083:5040132] 2---{number = 1, name = main}
2018-02-23 20:44:29.390459+0800 YSC-GCD-demo[20083:5040132] 3---{number = 1, name = main}
2018-02-23 20:44:31.391965+0800 YSC-GCD-demo[20083:5040132] 3---{number = 1, name = main}
2018-02-23 20:44:31.392513+0800 YSC-GCD-demo[20083:5040347] syncMain---end
在其他線程中使用同步執行 + 主隊列可看到：
a.所有任務都是在主線程(非當前線程)中執行的，沒有開啟新的線程(所有放在主隊列中的任務，都會放到主線程中執行)。
b.所有任務都在打印的syncConcurrent---begin和syncConcurrent---end之間執行(同步任務需要等待隊列的任務執行結束)。
c.任務是按順序執行的(主隊列是串行隊列，每次只有一個任務被執行，任務一個接一個按順序執行)。
為什么現在就不會卡住了呢？
因為syncMain 任務放到了其他線程里，而任務1、任務2、任務3都在追加到主隊列中，這三個任務都會在主線程中執行。syncMain任務在其他線程中執行到追加任務1到主隊列中，因為主隊列現在沒有正在執行的任務，所以，會直接執行主隊列的任務1，等任務1執行完畢，再接著執行任務2、任務3。所以這里不會卡住線程。
4.6 異步執行 + 主隊列
只在主線程中執行任務，執行完一個任務，再執行下一個任務。/**
* 異步執行 + 主隊列
* 特點：只在主線程中執行任務，執行完一個任務，再執行下一個任務
*/
- (void)asyncMain {
NSLog(@"currentThread---%@",[NSThreadcurrentThread]);// 打印當前線程
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---{number = 1, name = main}
2018-02-23 20:45:49.981935+0800 YSC-GCD-demo[20111:5046708] asyncMain---begin
2018-02-23 20:45:49.982352+0800 YSC-GCD-demo[20111:5046708] asyncMain---end
2018-02-23 20:45:51.991096+0800 YSC-GCD-demo[20111:5046708] 1---{number = 1, name = main}
2018-02-23 20:45:53.991959+0800 YSC-GCD-demo[20111:5046708] 1---{number = 1, name = main}
2018-02-23 20:45:55.992937+0800 YSC-GCD-demo[20111:5046708] 2---{number = 1, name = main}
2018-02-23 20:45:57.993649+0800 YSC-GCD-demo[20111:5046708] 2---{number = 1, name = main}
2018-02-23 20:45:59.994928+0800 YSC-GCD-demo[20111:5046708] 3---{number = 1, name = main}
2018-02-23 20:46:01.995589+0800 YSC-GCD-demo[20111:5046708] 3---{number = 1, name = main}
在異步執行 + 主隊列可以看到：
a.所有任務都是在當前線程(主線程)中執行的，并沒有開啟新的線程(雖然異步執行具備開啟線程的能力，但因為是主隊列，所以所有任務都在主線程中)。
b.所有任務是在打印的syncConcurrent---begin和syncConcurrent---end之后才開始執行的(異步執行不會做任何等待，可以繼續執行任務)。
c.任務是按順序執行的(因為主隊列是串行隊列，每次只有一個任務被執行，任務一個接一個按順序執行)。
弄懂了難理解、繞來繞去的隊列+任務之后，我們來學習一個簡單的東西：5. GCD 線程間的通信。
總結
以上是生活随笔為你收集整理的c语言gcd 简易函数,简单[GCD]用法详细总结(上)的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 华林SAP论坛(华林自建的SAP论坛)
- 下一篇： java 数列求和