整理多線程:GCD詳解

時間 2019-11-05

標籤整理多線程 gcd 詳解欄目 Java 简体版

原文原文鏈接

1、GCD簡介

Grand Central Dispatch(GCD) 是 Apple 開發的一個多核編程的較新的解決方法。
它主要用於優化應用程序以支持多核處理器以及其餘對稱多處理系統。是一個在線程池模式的基礎上執行的併發任務
複製代碼

爲何要用 GCD 呢？程序員

1. GCD 可用於多核的並行運算
2. GCD 會自動利用更多的 CPU 內核（好比雙核、四核）
3. GCD 會自動管理線程的生命週期（建立線程、調度任務、銷燬線程）
4. 程序員只須要告訴GCD想要執行什麼任務，不須要編寫任何線程管理代碼 
複製代碼

2、GCD 任務和隊列

2.1 任務

任務就是執行操做的意思，也就是在線程中所須要執行的那段代碼，在GCD中的block中實現。
複製代碼

執行任務分爲兩種方式: 同步執行 (sync) 和 異步執行 (async)編程

同步執行安全

1.同步添加任務到指定的隊列中，在添加的任務執行結束以前，會一直等待，直到隊列裏面的任務完成以後再繼續執行。
2.只能在當前線程中執行任務，不具有開啓新線程的能力。
複製代碼

異步執行bash

1.異步添加任務到指定的隊列中，它不會作任何等待，能夠繼續執行任務。
2.能夠在新的線程中執行任務，具有開啓新線程的能力。
複製代碼

區別session

是否等待隊列的任務執行結束，以及是否具有開啓新線程的能力
複製代碼

2.2 隊列（Dispatch Queue）

指執行任務的等待隊列，即用來存聽任務的隊列。

隊列是一種特殊的線性表，採用FIFO（先進先出）的原則，即新任務老是被插入到隊列的末尾，而讀取任務的時候老是從隊列的頭部開始讀取。
每讀取一個任務，則從隊列中釋放一個任務。
複製代碼

如圖:多線程

在GCD中有兩種隊列:併發

串行隊列（Serial Dispatch Queue）app

每次只有一個任務被執行。讓任務一個接着一個地執行。（只開啓一個線程，一個任務執行完畢後，再執行下一個任務）
複製代碼

併發隊列（Concurrent Dispatch Queue）異步

可讓多個任務併發（同時）執行。（能夠開啓多個線程，而且同時執行任務）
複製代碼

注意：併發隊列 的併發功能只有在異步（dispatch_async）函數下才有效
複製代碼

區別：async

執行順序不一樣，以及開啓線程數不一樣
複製代碼

二者具體區別以下兩圖所示：

3、GCD的使用步驟

GCD 的使用步驟其實很簡單，只有兩步:

1.建立一個隊列（串行隊列或併發隊列）
2.將任務追加到任務的等待隊列中，而後系統就會根據任務類型執行任務（同步執行或異步執行
複製代碼

3.1 隊列的建立和獲取

dispatch_queue_create

使用 dispatch_queue_create 來建立隊列，須要傳入兩個參數:

1. 第一個參數表示隊列的惟一標識符，用於 DEBUG，可爲空，Dispatch Queue 的名稱推薦使用應用程序 ID 這種逆序全程域名

2. 第二個參數用來識別是串行隊列仍是併發隊列。DISPATCH_QUEUE_SERIAL 表示串行隊列，DISPATCH_QUEUE_CONCURRENT 表示併發隊列
複製代碼

方法以下：

// 串行隊列的建立方法
dispatch_queue_t queue = dispatch_queue_create("net.gcd.testQueue", DISPATCH_QUEUE_SERIAL);

// 併發隊列的建立方法
dispatch_queue_t queue = dispatch_queue_create("net.gcd.testQueue", DISPATCH_QUEUE_CONCURRENT);
複製代碼

主隊列（Main Dispatch Queue）

主隊列屬於GCD中的一種特殊的串行隊列，主要有如下特色：

1. 全部放在主隊列中的任務，都會放到主線程中執行。

2.可以使用 dispatch_get_main_queue() 得到主隊列。
複製代碼

獲取方法：

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

全局併發隊列（Global Dispatch Queue）

在併發隊列中使用，可使用dispatch_get_global_queue 來獲取。須要傳入兩個參數:

1.第一個參數表示隊列優先級，通常用DISPATCH_QUEUE_PRIORITY_DEFAULT。

2.第二個參數暫時沒用，用0便可
複製代碼

獲取方法：

// 全局併發隊列的獲取方法
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
複製代碼

3.2 任務的建立方法

GCD 提供了同步執行任務的建立方法dispatch_sync和異步執行任務建立方法dispatch_async

// 同步執行任務建立方法
dispatch_sync(queue, ^{
    // 這裏放同步執行任務代碼
});

// 異步執行任務建立方法
dispatch_async(queue, ^{
    // 這裏放異步執行任務代碼
});
複製代碼

雖然使用 GCD 只需兩步，可是既然咱們有兩種隊列（串行隊列/併發隊列），兩種任務執行方式（同步執行/異步執行），那麼咱們就有了四種不一樣的組合方式。這四種不一樣的組合方式是：

1. 同步執行 + 併發隊列
2. 異步執行 + 併發隊列
3. 同步執行 + 串行隊列
4. 異步執行 + 串行隊列

複製代碼

實際上，剛纔還說了兩種特殊隊列：全局併發隊列、主隊列。全局併發隊列能夠做爲普通併發隊列來使用。可是主隊列由於有點特殊，因此咱們就又多了兩種組合方式。這樣就有六種不一樣的組合方式了

5. 同步執行 + 主隊列
6. 異步執行 + 主隊列
複製代碼

不一樣組合方式之間的區別:

區別	串行隊列	併發隊列	主隊列
同步(sync)	沒有開啓新線程，串行執行任務	沒有開啓新線程，串行執行任務	沒有開啓新線程，串行執行任務
異步(async)	有開啓新線程(1條)，串行執行任務	有開啓新線程，併發執行任務	沒有開啓新線程，串行執行任務

4、GCD的基本使用

4.一、同步執行 + 併發隊列

在當前線程中執行任務，不會開啓新線程，執行完一個任務，再執行下一個任務。

/**
 * 同步執行 + 併發隊列
 * 特色：在當前線程中執行任務，不會開啓新線程，執行完一個任務，再執行下一個任務。
 */
- (void)syncConcurrentTask{
    NSLog(@"當前線程 : %@",[NSThread currentThread]);
    NSLog(@"syncConcurrentTask : begin");

    dispatch_queue_t queue = dispatch_queue_create("net.gcd.testQueue", DISPATCH_QUEUE_CONCURRENT);
    
    //任務1
    dispatch_sync(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務1線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
        
    });
    
    //任務2
    dispatch_sync(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務2線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
        
    });

    //任務3
    dispatch_sync(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務3線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
    });

    NSLog(@"syncConcurrentTask : end");
}

日誌輸出:

2019-08-15 11:37:01.882803+0800 XKHttpNetworkHelper[31452:1205128] 當前線程 : <NSThread: 0x600002901300>{number = 1, name = main}
2019-08-15 11:37:01.882926+0800 XKHttpNetworkHelper[31452:1205128] syncConcurrentTask : begin
2019-08-15 11:37:03.883808+0800 XKHttpNetworkHelper[31452:1205128] 任務1線程: <NSThread: 0x600002901300>{number = 1, name = main}
2019-08-15 11:37:05.884233+0800 XKHttpNetworkHelper[31452:1205128] 任務1線程: <NSThread: 0x600002901300>{number = 1, name = main}
2019-08-15 11:37:07.884623+0800 XKHttpNetworkHelper[31452:1205128] 任務2線程: <NSThread: 0x600002901300>{number = 1, name = main}
2019-08-15 11:37:10.057093+0800 XKHttpNetworkHelper[31452:1205128] 任務2線程: <NSThread: 0x600002901300>{number = 1, name = main}
2019-08-15 11:37:12.057729+0800 XKHttpNetworkHelper[31452:1205128] 任務3線程: <NSThread: 0x600002901300>{number = 1, name = main}
2019-08-15 11:37:14.058287+0800 XKHttpNetworkHelper[31452:1205128] 任務3線程: <NSThread: 0x600002901300>{number = 1, name = main}
2019-08-15 11:37:14.058435+0800 XKHttpNetworkHelper[31452:1205128] syncConcurrentTask : end
複製代碼

從執行 (同步執行 + 併發隊列) 任務的輸出日誌中能夠看到:

1. 全部任務都是在當前線程（主線程）中執行的，沒有開啓新的線程（同步執行不具有開啓新線程的能力。

2. 全部任務都在打印的syncConcurrentTask:begin和syncConcurrentTask:end之間執行的（同步任務須要等待隊列的任務執行結束）。

3. 任務按順序執行的。
   按順序執行的緣由：雖然併發隊列能夠開啓多個線程，而且同時執行多個任務。
   可是由於自己不能建立新線程，只有當前線程這一個線程（同步任務不具有開啓新線程的能力），因此也就不存在併發。
   並且當前線程只有等待當前隊列中正在執行的任務執行完畢以後，才能繼續接着執行下面的操做（同步任務須要等待隊列的任務執行結束）。
   因此任務只能一個接一個按順序執行，不能同時被執行
複製代碼

4.二、異步執行 + 併發隊列

能夠開啓多個線程，，任務交替(同時)執行

/**
 * 異步執行 + 併發隊列
 * 特色：能夠開啓多個線程，任務交替（同時）執行。
 */
- (void)asyncConcurrentTask {
    NSLog(@"當前線程 : %@",[NSThread currentThread]);
    NSLog(@"asyncConcurrentTask : begin");
    
    dispatch_queue_t queue = dispatch_queue_create("net.gcd.testQueue", DISPATCH_QUEUE_CONCURRENT);
    
    //任務1
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務1線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
        
    });
    
    //任務2
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務2線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
        
    });
    
    //任務3
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務3線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
    });
    
    NSLog(@"asyncConcurrentTask : end");
}

日誌輸出:

2019-08-15 13:53:45.774625+0800 XKHttpNetworkHelper[33086:1319354] 當前線程 : <NSThread: 0x600000712340>{number = 1, name = main}
2019-08-15 13:53:45.774757+0800 XKHttpNetworkHelper[33086:1319354] asyncConcurrentTask : begin
2019-08-15 13:53:45.774857+0800 XKHttpNetworkHelper[33086:1319354] asyncConcurrentTask : end
2019-08-15 13:53:47.778932+0800 XKHttpNetworkHelper[33086:1319430] 任務3線程: <NSThread: 0x60000074c040>{number = 3, name = (null)}
2019-08-15 13:53:47.778932+0800 XKHttpNetworkHelper[33086:1319431] 任務2線程: <NSThread: 0x600000750180>{number = 5, name = (null)}
2019-08-15 13:53:47.778932+0800 XKHttpNetworkHelper[33086:1319432] 任務1線程: <NSThread: 0x600000769000>{number = 4, name = (null)}

2019-08-15 13:53:49.784350+0800 XKHttpNetworkHelper[33086:1319432] 任務1線程: <NSThread: 0x600000769000>{number = 4, name = (null)}
2019-08-15 13:53:49.784341+0800 XKHttpNetworkHelper[33086:1319430] 任務3線程: <NSThread: 0x60000074c040>{number = 3, name = (null)}
2019-08-15 13:53:49.784359+0800 XKHttpNetworkHelper[33086:1319431] 任務2線程: <NSThread: 0x600000750180>{number = 5, name = (null)}
複製代碼

從執行 (異步執行 + 併發隊列) 任務的輸出日誌中能夠看到:

1. 除了當前線程（主線程），系統又開啓了3個線程，而且任務是交替/同時執行的。（異步執行具有開啓新線程的能力。且併發隊列可開啓多個線程，同時執行多個任務）

2. 全部任務都在打印的asyncConcurrentTask:begin和asyncConcurrentTask:end以後執行的。說明當前線程沒有等待，而是直接開啓了新線程，在新線程中執行任務(異步執行沒必要等待，能夠繼續執行任務)
複製代碼

4.三、同步執行 + 串行隊列

不會開啓新線程，在當前線程執行任務。任務是串行的，執行完一個任務，再執行下一個任務

/**
 * 同步執行 + 串行隊列
 * 特色：不會開啓新線程，在當前線程執行任務。任務是串行的，執行完一個任務，再執行下一個任務。
 */
- (void)syncSerialTask{
    NSLog(@"當前線程 : %@",[NSThread currentThread]);
    NSLog(@"syncSerialTask : begin");

    dispatch_queue_t queue = dispatch_queue_create("net.gcd.testQueue", DISPATCH_QUEUE_SERIAL);
    
    //任務1
    dispatch_sync(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務1線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
        
    });
    
    //任務2
    dispatch_sync(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務2線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
        
    });

    //任務3
    dispatch_sync(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務3線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
    });

    NSLog(@"syncSerialTask : end");
}

日誌輸出:

2019-08-15 14:17:24.193189+0800 XKHttpNetworkHelper[33428:1377743] 當前線程 : <NSThread: 0x6000009c1480>{number = 1, name = main}
2019-08-15 14:17:24.193313+0800 XKHttpNetworkHelper[33428:1377743] syncSerialTask : begin
2019-08-15 14:17:26.194075+0800 XKHttpNetworkHelper[33428:1377743] 任務1線程: <NSThread: 0x6000009c1480>{number = 1, name = main}
2019-08-15 14:17:28.194587+0800 XKHttpNetworkHelper[33428:1377743] 任務1線程: <NSThread: 0x6000009c1480>{number = 1, name = main}
2019-08-15 14:17:30.195848+0800 XKHttpNetworkHelper[33428:1377743] 任務2線程: <NSThread: 0x6000009c1480>{number = 1, name = main}
2019-08-15 14:17:32.196502+0800 XKHttpNetworkHelper[33428:1377743] 任務2線程: <NSThread: 0x6000009c1480>{number = 1, name = main}
2019-08-15 14:17:34.196834+0800 XKHttpNetworkHelper[33428:1377743] 任務3線程: <NSThread: 0x6000009c1480>{number = 1, name = main}
2019-08-15 14:17:36.197151+0800 XKHttpNetworkHelper[33428:1377743] 任務3線程: <NSThread: 0x6000009c1480>{number = 1, name = main}
2019-08-15 14:17:36.197387+0800 XKHttpNetworkHelper[33428:1377743] syncSerialTask : end
複製代碼

從執行 (同步執行 + 串行隊列) 任務的輸出日誌中能夠看到:

1. 全部任務都是在當前線程（主線程）中執行的，並無開啓新的線程（同步執行不具有開啓新線程的能力）。

2. 全部任務都在打印的syncSerialTask: begin和syncSerialTask : end之間執行（同步任務須要等待隊列的任務執行結束）。

3. 任務是按順序執行的（串行隊列每次只有一個任務被執行，任務一個接一個按順序執行）。
複製代碼

4.四、異步執行 + 串行隊列

會開啓新線程，可是由於任務是串行的，執行完一個任務，再執行下一個任務

/**
 * 異步執行 + 串行隊列
 * 特色：會開啓新線程，可是由於任務是串行的，執行完一個任務，再執行下一個任務。
 */
- (void)asyncSerialTask {
    NSLog(@"當前線程 : %@",[NSThread currentThread]);
    NSLog(@"asyncSerialTask : begin");
    
    dispatch_queue_t queue = dispatch_queue_create("net.gcd.testQueue", DISPATCH_QUEUE_SERIAL);
    
    //任務1
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務1線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
        
    });
    
    //任務2
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務2線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
        
    });
    
    //任務3
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務3線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
    });
    
    NSLog(@"asyncSerialTask : end");
}

日誌輸出:

2019-08-15 14:23:59.070912+0800 XKHttpNetworkHelper[33542:1394792] 當前線程 : <NSThread: 0x600002554d00>{number = 1, name = main}
2019-08-15 14:23:59.071072+0800 XKHttpNetworkHelper[33542:1394792] asyncSerialTask : begin
2019-08-15 14:23:59.071207+0800 XKHttpNetworkHelper[33542:1394792] asyncSerialTask : end
2019-08-15 14:24:01.076086+0800 XKHttpNetworkHelper[33542:1394881] 任務1線程: <NSThread: 0x60000251b9c0>{number = 3, name = (null)}
2019-08-15 14:24:03.080528+0800 XKHttpNetworkHelper[33542:1394881] 任務1線程: <NSThread: 0x60000251b9c0>{number = 3, name = (null)}
2019-08-15 14:24:05.085977+0800 XKHttpNetworkHelper[33542:1394881] 任務2線程: <NSThread: 0x60000251b9c0>{number = 3, name = (null)}
2019-08-15 14:24:07.091084+0800 XKHttpNetworkHelper[33542:1394881] 任務2線程: <NSThread: 0x60000251b9c0>{number = 3, name = (null)}
2019-08-15 14:24:09.094797+0800 XKHttpNetworkHelper[33542:1394881] 任務3線程: <NSThread: 0x60000251b9c0>{number = 3, name = (null)}
2019-08-15 14:24:11.097145+0800 XKHttpNetworkHelper[33542:1394881] 任務3線程: <NSThread: 0x60000251b9c0>{number = 3, name = (null)}

複製代碼

從執行 (異步執行 + 串行隊列) 任務的輸出日誌中能夠看到:

1. 開啓了一條新線程（異步執行具有開啓新線程的能力，串行隊列只開啓一個線程）。

2. 全部任務是在打印的asyncSerialTask : begin和asyncSerialTask : end以後纔開始執行的（異步執行不會作任何等待，能夠繼續執行任務）。

3. 任務是按順序執行的（串行隊列每次只有一個任務被執行，任務一個接一個按順序執行）。
複製代碼

4.五、同步執行 + 主隊列

主隊列: GCD自帶的一種特殊的串行隊列

1. 全部放在主隊列中的任務，都會放到主線程中執行

2. 可以使用dispatch_get_main_queue()得到主隊列
複製代碼

注意:

同步執行 + 主隊列在不一樣線程中調用結果也是不同，在主線程中調用會出現死鎖，而在其餘線程中則不會。
在這裏作一個解釋，致使死鎖的緣由，是在同一個串行隊列任務中，兩個任務相互依賴所致使的，
並不侷限於同步執行 + 主隊列的模式，在這裏只是舉例說明。
複製代碼

在主線程中調用同步執行 + 主隊列

互相等待卡住不可行

/**
 * 同步執行 + 主隊列
 * 特色(主線程調用)：互等卡主不執行。
 * 特色(其餘線程調用)：不會開啓新線程，執行完一個任務，再執行下一個任務。
 */
- (void)syncMainTask{
    NSLog(@"當前線程 : %@",[NSThread currentThread]);
    NSLog(@"syncMainTask : begin");

    dispatch_queue_t queue = dispatch_get_main_queue();
    
    //任務1
    dispatch_sync(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務1線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
        
    });
    
    //任務2
    dispatch_sync(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務2線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
        
    });

    //任務3
    dispatch_sync(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務3線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
    });

    NSLog(@"syncMainTask : end");
}

日誌輸出:

2019-08-15 14:30:36.746214+0800 XKHttpNetworkHelper[33641:1411969] 當前線程 : <NSThread: 0x6000013d40c0>{number = 1, name = main}
2019-08-15 14:30:36.746396+0800 XKHttpNetworkHelper[33641:1411969] syncMainTask : begin
(lldb) 

複製代碼

從主線程執行 (同步執行 + 主隊列) 任務的輸出日誌中能夠看到:

1. 在主線程中使用同步執行 + 主隊列，追加到主線程的任務一、任務二、任務3都再也不執行了，syncMainTask: end也沒有打印
複製代碼

於此同時，在Xcode上執行該代碼時，還會出現崩潰，這是爲何呢?

答: 當在主線程中執行syncMainTask方法，至關於把syncMainTask 任務放到了主線程的隊列中。 而同步執行會等待當前隊列中的任務執行完畢，纔會接着執行下一個任務。
那麼當把任務1追加到主隊列中，任務1就在等待主線程處理syncMainTask任務，而syncMainTask任務須要等待任務1執行完畢，纔會接着執行。
那麼，當syncMainTask任務和任務1都在等待對方執行完畢，這就致使了線程卡住了，隊列中的任務也執行不了，因此也沒有打印syncMainTask: end
複製代碼

在其餘線程中調用同步執行 + 主隊列

不會開啓新線程，執行完一個任務，再執行下一個任務。

// 使用 NSThread 的 detachNewThreadSelector 方法會建立線程，並自動啓動線程執行

[NSThread detachNewThreadSelector:@selector(syncMainTask) toTarget:self withObject:nil];

日誌輸出: 

2019-08-15 14:38:37.113023+0800 XKHttpNetworkHelper[33757:1426643] 當前線程 : <NSThread: 0x600001269280>{number = 3, name = (null)}
2019-08-15 14:38:37.113231+0800 XKHttpNetworkHelper[33757:1426643] syncMainTask : begin
2019-08-15 14:38:39.124858+0800 XKHttpNetworkHelper[33757:1426494] 任務1線程: <NSThread: 0x600001216900>{number = 1, name = main}
2019-08-15 14:38:41.125326+0800 XKHttpNetworkHelper[33757:1426494] 任務1線程: <NSThread: 0x600001216900>{number = 1, name = main}
2019-08-15 14:38:43.127719+0800 XKHttpNetworkHelper[33757:1426494] 任務2線程: <NSThread: 0x600001216900>{number = 1, name = main}
2019-08-15 14:38:45.128980+0800 XKHttpNetworkHelper[33757:1426494] 任務2線程: <NSThread: 0x600001216900>{number = 1, name = main}
2019-08-15 14:38:47.131208+0800 XKHttpNetworkHelper[33757:1426494] 任務3線程: <NSThread: 0x600001216900>{number = 1, name = main}
2019-08-15 14:38:49.131635+0800 XKHttpNetworkHelper[33757:1426494] 任務3線程: <NSThread: 0x600001216900>{number = 1, name = main}
2019-08-15 14:38:49.132000+0800 XKHttpNetworkHelper[33757:1426643] syncMainTask : end
複製代碼

從其餘線程執行 (同步執行 + 主隊列) 任務的輸出日誌中能夠看到:

1. 全部任務都是在主線程（非當前線程）中執行的，沒有開啓新的線程（全部放在主隊列中的任務，都會放到主線程中執行）。

2. 全部任務都在打印的syncMainTask : begin和syncMainTask : end之間執行（同步任務須要等待隊列的任務執行結束）。

3. 任務是按順序執行的（主隊列是串行隊列，每次只有一個任務被執行，任務一個接一個按順序執行）。
複製代碼

爲何在其餘線程執行，就不會卡住了呢？

答： 由於 syncMainTask 放到了其餘線程裏，而任務一、任務二、任務3都追加在主隊列中，這三個任務都會在主線程中執行。
    syncMainTask任務在其餘線程中執行追加到任務1到隊列中，由於主隊列如今沒有正在執行的任務，
    因此，會直接執行主隊列的任務1，等任務1執行完畢，再接着執行任務二、任務3。因此這裏不會卡住線程。
複製代碼

4.五、異步執行 + 主隊列

只在主線程中執行任務，執行完一個任務，再執行下一個任務。

/**
 * 異步執行 + 主隊列
 * 特色：只在主線程中執行任務，執行完一個任務，再執行下一個任務
 */
- (void)asyncMainTask {
    NSLog(@"當前線程 : %@",[NSThread currentThread]);
    NSLog(@"asyncMainTask : begin");
    
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    //任務1
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務1線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
        
    });
    
    //任務2
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務2線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
        
    });
    
    //任務3
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務3線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
    });
    
    NSLog(@"asyncMainTask : end");
}

日誌輸出：


2019-08-15 14:47:20.946679+0800 XKHttpNetworkHelper[33880:1443430] 當前線程 : <NSThread: 0x6000031a0c40>{number = 1, name = main}
2019-08-15 14:47:20.946835+0800 XKHttpNetworkHelper[33880:1443430] asyncMainTask : begin
2019-08-15 14:47:20.946933+0800 XKHttpNetworkHelper[33880:1443430] asyncMainTask : end
2019-08-15 14:47:22.961664+0800 XKHttpNetworkHelper[33880:1443430] 任務1線程: <NSThread: 0x6000031a0c40>{number = 1, name = main}
2019-08-15 14:47:24.961989+0800 XKHttpNetworkHelper[33880:1443430] 任務1線程: <NSThread: 0x6000031a0c40>{number = 1, name = main}
2019-08-15 14:47:26.962337+0800 XKHttpNetworkHelper[33880:1443430] 任務2線程: <NSThread: 0x6000031a0c40>{number = 1, name = main}
2019-08-15 14:47:28.962802+0800 XKHttpNetworkHelper[33880:1443430] 任務2線程: <NSThread: 0x6000031a0c40>{number = 1, name = main}
2019-08-15 14:47:30.964399+0800 XKHttpNetworkHelper[33880:1443430] 任務3線程: <NSThread: 0x6000031a0c40>{number = 1, name = main}
2019-08-15 14:47:32.965105+0800 XKHttpNetworkHelper[33880:1443430] 任務3線程: <NSThread: 0x6000031a0c40>{number = 1, name = main}
複製代碼

從執行 (異步執行 + 主隊列) 任務的輸出日誌中能夠看到:

1. 全部任務都是在當前線程（主線程）中執行的，並無開啓新的線程（雖然異步執行具有開啓線程的能力，但由於是主隊列，因此全部任務都在主線程中）。

2. 全部任務是在打印的syncConcurrent---begin和syncConcurrent---end以後纔開始執行的（異步執行不會作任何等待，能夠繼續執行任務）。

3. 任務是按順序執行的（由於主隊列是串行隊列，每次只有一個任務被執行，任務一個接一個按順序執行）。
複製代碼

5、GCD線程間的通訊

在 iOS 開發過程當中，咱們通常在主線程裏邊進行 UI 刷新，例如：點擊、滾動、拖拽等事件。咱們一般把一些耗時的操做放在其餘線程，好比說圖片下載、文件上傳等耗時操做。而當咱們有時候在其餘線程完成了耗時操做時，須要回到主線程，那麼就用到了線程之間的通信。

/**
 * 線程間通訊
 */
- (void)reloadDatas{
    // 獲取全局併發隊列
    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 (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"異步線程: %@",[NSThread currentThread]);       // 打印當前線程
        }
        
        dispatch_async(mainQueue, ^{
            //主線程，更新UI等等
            
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"主線程: %@",[NSThread currentThread]);       // 打印當前線程
        });
    });
}

日誌輸出: 

2019-08-15 14:53:19.932779+0800 XKHttpNetworkHelper[33980:1459145] 異步線程: <NSThread: 0x600002500240>{number = 3, name = (null)}
2019-08-15 14:53:21.937532+0800 XKHttpNetworkHelper[33980:1459145] 異步線程: <NSThread: 0x600002500240>{number = 3, name = (null)}
2019-08-15 14:53:23.937934+0800 XKHttpNetworkHelper[33980:1459058] 主線程: <NSThread: 0x600002572940>{number = 1, name = main}
複製代碼

從執行任務的結果上看:

1. 能夠看到在其餘線程中先執行任務，執行完了以後回到主線程執行主線程的相應操做。
複製代碼

6、GCD 的特殊方法

6.1 柵欄方法: dispatch_barrier_async

在平常開發過程當中，有時候須要異步執行兩組操做，並且第一組操做執行完以後，才能開始執行第二組操做。這樣咱們就須要一個至關於柵欄同樣的一個方法將兩組異步執行的操做組給分割起來，固然這裏的操做組裏能夠包含一個或多個任務。這就須要用到 dispatch_barrier_async 方法在兩個操做組間造成柵欄。

dispatch_barrier_async 函數會等待前邊追加到併發隊列中的任務所有執行完畢以後，再將指定的任務追加到該異步隊列中。
後在 dispatch_barrier_async 函數追加的任務執行完畢以後，異步隊列才恢復爲通常動做，接着追加任務到該異步隊列並開始執行。
複製代碼

如圖：

/**
 * 柵欄方法
 */
- (void)barrierAsyncTask{
    NSLog(@"當前線程 : %@",[NSThread currentThread]);
    NSLog(@"barrierAsyncTask : begin");
    
    dispatch_queue_t queue = dispatch_queue_create("net.gcd.testQueue", DISPATCH_QUEUE_CONCURRENT);
    
    //任務1
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務1線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
        
    });
    
    //任務2
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務2線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
    });
    
    //柵欄方法
    dispatch_barrier_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"柵欄方法 barrier: %@",[NSThread currentThread]);      // 打印當前線程
        }
    });
    
    
    //任務3
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務3線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
    });
    
    //任務4
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務4線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
    });
    NSLog(@"barrierAsyncTask : end");
}


日誌輸出:

2019-08-16 10:19:29.248058+0800 XKHttpNetworkHelper[1243:102722] 當前線程 : <NSThread: 0x6000016929c0>{number = 1, name = main}
2019-08-16 10:19:29.248226+0800 XKHttpNetworkHelper[1243:102722] barrierAsyncTask : begin
2019-08-16 10:19:29.248329+0800 XKHttpNetworkHelper[1243:102722] barrierAsyncTask : end
2019-08-16 10:19:31.252557+0800 XKHttpNetworkHelper[1243:103201] 任務1線程: <NSThread: 0x6000016c0080>{number = 3, name = (null)}
2019-08-16 10:19:31.252557+0800 XKHttpNetworkHelper[1243:103203] 任務2線程: <NSThread: 0x6000016fbc00>{number = 4, name = (null)}
2019-08-16 10:19:33.256810+0800 XKHttpNetworkHelper[1243:103203] 任務2線程: <NSThread: 0x6000016fbc00>{number = 4, name = (null)}
2019-08-16 10:19:33.256827+0800 XKHttpNetworkHelper[1243:103201] 任務1線程: <NSThread: 0x6000016c0080>{number = 3, name = (null)}

2019-08-16 10:19:35.260173+0800 XKHttpNetworkHelper[1243:103203] 柵欄方法 barrier: <NSThread: 0x6000016fbc00>{number = 4, name = (null)}
2019-08-16 10:19:37.262588+0800 XKHttpNetworkHelper[1243:103203] 柵欄方法 barrier: <NSThread: 0x6000016fbc00>{number = 4, name = (null)}

2019-08-16 10:19:39.266496+0800 XKHttpNetworkHelper[1243:103201] 任務4線程: <NSThread: 0x6000016c0080>{number = 3, name = (null)}
2019-08-16 10:19:39.266509+0800 XKHttpNetworkHelper[1243:103203] 任務3線程: <NSThread: 0x6000016fbc00>{number = 4, name = (null)}
2019-08-16 10:19:41.271556+0800 XKHttpNetworkHelper[1243:103203] 任務3線程: <NSThread: 0x6000016fbc00>{number = 4, name = (null)}
2019-08-16 10:19:41.271556+0800 XKHttpNetworkHelper[1243:103201] 任務4線程: <NSThread: 0x6000016c0080>{number = 3, name = (null)}
複製代碼

從執行任務的輸出日誌中能夠看到:

1. 在執行完柵欄前面的操做以後，才執行柵欄操做，最後再執行柵欄後邊的操做。
複製代碼

6.2 延時方法: dispatch_after

在一些平常的開發任務中，會遇到這樣的需求: 在指定時間(例如3秒)以後執行某個任務。能夠用 dispatch_after 函數來實現。須要注意的是：

dispatch_after 函數並非在指定時間以後纔開始執行處理，而是在指定時間以後將任務追加到主隊列中。
嚴格來講，這個時間並非絕對準確的，但想要大體延遲執行任務，dispatch_after函數是頗有效的
複製代碼

/**
 * 延時執行方法 dispatch_after
 */
- (void)afterTask {
    NSLog(@"當前線程 : %@",[NSThread currentThread]);
    NSLog(@"afterTask : begin");
    
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        // 2.0秒後異步追加任務代碼到主隊列，並開始執行
        NSLog(@"延時任務: %@",[NSThread currentThread]);  // 打印當前線程
    });
    
    NSLog(@"afterTask : end");
}

日誌輸出:

2019-08-16 10:32:09.909632+0800 XKHttpNetworkHelper[1406:131070] 當前線程 : <NSThread: 0x600003b32940>{number = 1, name = main}
2019-08-16 10:32:09.909756+0800 XKHttpNetworkHelper[1406:131070] afterTask : begin
2019-08-16 10:32:09.909846+0800 XKHttpNetworkHelper[1406:131070] afterTask : end

//間隔2後纔打印
2019-08-16 10:32:12.105720+0800 XKHttpNetworkHelper[1406:131070] 延時任務: <NSThread: 0x600003b32940>{number = 1, name = main}
複製代碼

6.3 一次性代碼（只執行一次）: dispatch_once

在實現單例建立或者整個程序運行過程只執行一次的代碼時，就可使用到 dispatch_once 函數。

使用 dispatch_once 函數能保證某段代碼在程序運行過程當中只被執行一次，而且即便多線程的環境下，dispatch_once 也能夠保證線程安全
複製代碼

/**
 * 一次性代碼（只執行一次）dispatch_once
 */
- (void)onceTask{
    static dispatch_once_t onceToken ;
    dispatch_once(&onceToken, ^{
         // 只執行1次的代碼(這裏面默認是線程安全的)
    });
}
複製代碼

6.4 快速迭代方法: dispatch_apply

一般狀況下，回使用for循環遍歷，可是GCD提供了快速迭代的方法 dispatch_apply

dispatch_apply按照指定的次數將指定的任務追加到指定的隊列中，並等待所有隊列執行結束。
複製代碼

還能夠利用異步隊列同時遍歷，例如：遍歷0-5 這6個數字，for循環的作法是每次取出一個元素，逐個遍歷。而dispatch_apply 能夠同時遍歷多個數字

/**
 *  快速迭代方法 dispatch_apply
 */
- (void)applyTask{
    NSLog(@"applyTask : begin");
    
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_apply(6, queue, ^(size_t index) {
        NSLog(@"applyTask -- %ld: %@",index,[NSThread currentThread]);  // 打印當前線程
    });
    NSLog(@"applyTask : end");
}

日誌輸出: 

2019-08-16 14:09:49.328469+0800 XKHttpNetworkHelper[17064:389593] applyTask : begin
2019-08-16 14:09:49.328685+0800 XKHttpNetworkHelper[17064:389662] applyTask -- 1: <NSThread: 0x600001d9ca80>{number = 3, name = (null)}
2019-08-16 14:09:49.328702+0800 XKHttpNetworkHelper[17064:389593] applyTask -- 0: <NSThread: 0x600001ded480>{number = 1, name = main}
2019-08-16 14:09:49.328708+0800 XKHttpNetworkHelper[17064:389677] applyTask -- 5: <NSThread: 0x600001daa300>{number = 5, name = (null)}
2019-08-16 14:09:49.328711+0800 XKHttpNetworkHelper[17064:389675] applyTask -- 4: <NSThread: 0x600001db8100>{number = 4, name = (null)}
2019-08-16 14:09:49.328718+0800 XKHttpNetworkHelper[17064:389680] applyTask -- 3: <NSThread: 0x600001d83680>{number = 7, name = (null)}
2019-08-16 14:09:49.328723+0800 XKHttpNetworkHelper[17064:389676] applyTask -- 2: <NSThread: 0x600001db80c0>{number = 6, name = (null)}
2019-08-16 14:09:49.328862+0800 XKHttpNetworkHelper[17064:389593] applyTask : end
複製代碼

從執行任務的輸出日誌中能夠看到:

1. 使用dispatch_apply遍歷的過程當中，日誌輸出打印的結果順序不定，但 applyTask : end 是在最後才執行的
複製代碼

在併發隊列中異步執行任務，因此各個任務的執行時間長短不定，因此結束的順序也不定，可是 applyTask : end必定在最後才執行，這是由於 dispatch_apply 函數會等待所有任務執行完畢

6.5 隊列組: dispatch_group

在平常開發過程當中，可能回遇到相似於這樣的需求: 分別異步執行2個耗時任務，而後當2個耗時任務都執行完畢後再回到主線程執行任務。好比「多任務下載列表」，對於這種狀況的處理，咱們可使用 GCD的隊列組。

1. 調用隊列組的 dispatch_group_async 先把任務放到隊列中，而後將隊列放入隊列組中。或者使用隊列組的 dispatch_group_enter、dispatch_group_leave 組合 來實現
dispatch_group_async。

2. 調用隊列組的 dispatch_group_notify 回到指定線程執行任務。或者使用 dispatch_group_wait 回到當前線程繼續向下執行（會阻塞當前線程）。
複製代碼

6.5.1 dispatch_group_notify

監聽 group 中任務的完成狀態，當全部的任務都執行完成後，追加任務到 group 中，並執行任務。
複製代碼

/**
 * 隊列組 dispatch_group_notify
 */
- (void)asyncGroupTask{
    NSLog(@"當前線程 : %@",[NSThread currentThread]);
    NSLog(@"asyncGroupTask : begin");
    
    dispatch_group_t group = dispatch_group_create();
    
    //任務1
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務1線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
    });
    
    //任務2
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務2線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的異步任務一、任務2都執行完畢後，回到主線程執行下邊任務
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操做
            NSLog(@"主線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
        NSLog(@"asyncGroupTask : end");
    });
}

日誌輸出: 

2019-08-16 14:24:29.498165+0800 XKHttpNetworkHelper[17285:415433] 當前線程 : <NSThread: 0x600003d8a940>{number = 1, name = main}
2019-08-16 14:24:29.498303+0800 XKHttpNetworkHelper[17285:415433] asyncGroupTask : begin
2019-08-16 14:24:31.500079+0800 XKHttpNetworkHelper[17285:415495] 任務1線程: <NSThread: 0x600003de1dc0>{number = 4, name = (null)}
2019-08-16 14:24:31.500080+0800 XKHttpNetworkHelper[17285:415502] 任務2線程: <NSThread: 0x600003dd4380>{number = 3, name = (null)}
2019-08-16 14:24:33.502466+0800 XKHttpNetworkHelper[17285:415495] 任務1線程: <NSThread: 0x600003de1dc0>{number = 4, name = (null)}
2019-08-16 14:24:33.502506+0800 XKHttpNetworkHelper[17285:415502] 任務2線程: <NSThread: 0x600003dd4380>{number = 3, name = (null)}
2019-08-16 14:24:35.502939+0800 XKHttpNetworkHelper[17285:415433] 主線程: <NSThread: 0x600003d8a940>{number = 1, name = main}
2019-08-16 14:24:37.503722+0800 XKHttpNetworkHelper[17285:415433] 主線程: <NSThread: 0x600003d8a940>{number = 1, name = main}
2019-08-16 14:24:37.503999+0800 XKHttpNetworkHelper[17285:415433] asyncGroupTask : end
複製代碼

從執行任務的輸出日誌中能夠看到:

當全部任務都執行完成以後，才執行dispatch_group_notify block 中的任務。
複製代碼

6.5.2 dispatch_group_wait

暫停當前線程（阻塞當前線程），等待指定的 group 中的任務執行完成後，纔會往下繼續執行。
複製代碼

/**
 * 隊列組 dispatch_group_wait
 */
- (void)asyncGroupWaitTask{
    NSLog(@"當前線程 : %@",[NSThread currentThread]);
    NSLog(@"asyncGroupWaitTask : begin");
    
    dispatch_group_t group = dispatch_group_create();
    
    //任務1
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務1線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
    });
    
    //任務2
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務2線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
    });
    
    // 等待上面的任務所有完成後，會往下繼續執行（會阻塞當前線程）
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    
    NSLog(@"asyncGroupWaitTask : end");
}

日誌輸出: 

2019-08-19 09:56:49.433832+0800 XKHttpNetworkHelper[1752:316226] 當前線程 : <NSThread: 0x600003c7e900>{number = 1, name = main}
2019-08-19 09:56:49.434004+0800 XKHttpNetworkHelper[1752:316226] asyncGroupWaitTask : begin
2019-08-19 09:56:51.437733+0800 XKHttpNetworkHelper[1752:316342] 任務2線程: <NSThread: 0x600003c26e40>{number = 4, name = (null)}
2019-08-19 09:56:51.437754+0800 XKHttpNetworkHelper[1752:316341] 任務1線程: <NSThread: 0x600003c20140>{number = 3, name = (null)}
2019-08-19 09:56:53.439997+0800 XKHttpNetworkHelper[1752:316341] 任務1線程: <NSThread: 0x600003c20140>{number = 3, name = (null)}
2019-08-19 09:56:53.440009+0800 XKHttpNetworkHelper[1752:316342] 任務2線程: <NSThread: 0x600003c26e40>{number = 4, name = (null)}
2019-08-19 09:56:53.440181+0800 XKHttpNetworkHelper[1752:316226] asyncGroupWaitTask : end


//去除dispatch_group_wait後的日誌:

2019-08-19 09:58:26.873803+0800 XKHttpNetworkHelper[1855:321884] 當前線程 : <NSThread: 0x600003fd97c0>{number = 1, name = main}
2019-08-19 09:58:26.873944+0800 XKHttpNetworkHelper[1855:321884] asyncGroupWaitTask : begin
2019-08-19 09:58:26.874078+0800 XKHttpNetworkHelper[1855:321884] asyncGroupWaitTask : end
2019-08-19 09:58:28.877712+0800 XKHttpNetworkHelper[1855:322057] 任務1線程: <NSThread: 0x600003fa55c0>{number = 3, name = (null)}
2019-08-19 09:58:28.877736+0800 XKHttpNetworkHelper[1855:322065] 任務2線程: <NSThread: 0x600003f82fc0>{number = 4, name = (null)}
2019-08-19 09:58:30.880441+0800 XKHttpNetworkHelper[1855:322065] 任務2線程: <NSThread: 0x600003f82fc0>{number = 4, name = (null)}
2019-08-19 09:58:30.880441+0800 XKHttpNetworkHelper[1855:322057] 任務1線程: <NSThread: 0x600003fa55c0>{number = 3, name = (null)}
複製代碼

從執行任務的輸出日誌中能夠看到:

當全部任務執行完成以後，才執行 dispatch_group_wait 以後的操做。可是，使用dispatch_group_wait 會阻塞當前線程
複製代碼

6.5.3 dispatch_group_enter、dispatch_group_leave

1. dispatch_group_enter 標誌着一個任務追加到 group，執行一次，至關於 group 中未執行完畢任務數+1

2. dispatch_group_leave 標誌着一個任務離開了 group，執行一次，至關於 group 中未執行完畢任務數-1。

3. 當 group 中未執行完畢任務數爲0的時候，纔會使dispatch_group_wait解除阻塞，以及執行追加到dispatch_group_notify中的任務
複製代碼

/**
 * 隊列組 dispatch_group_enter、dispatch_group_leave
 */
- (void)asyncGroupEnterAndLeaveTask{
    NSLog(@"當前線程 : %@",[NSThread currentThread]);
    NSLog(@"asyncGroupEnterAndLeaveTask : begin");
    
    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    //任務1
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務1線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
        dispatch_group_leave(group);
    });
    
    //任務2
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務2線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
        dispatch_group_leave(group);
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的異步任務一、任務2都執行完畢後，回到主線程執行下邊任務
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操做
            NSLog(@"主線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
        NSLog(@"asyncGroupEnterAndLeaveTask : end");
    });
}

//日誌輸出: 

2019-08-19 10:43:30.184976+0800 XKHttpNetworkHelper[19410:485864] 當前線程 : <NSThread: 0x6000008fe3c0>{number = 1, name = main}
2019-08-19 10:43:30.185190+0800 XKHttpNetworkHelper[19410:485864] asyncGroupEnterAndLeaveTask : begin
2019-08-19 10:43:32.189332+0800 XKHttpNetworkHelper[19410:486006] 任務1線程: <NSThread: 0x600000885400>{number = 4, name = (null)}
2019-08-19 10:43:32.189332+0800 XKHttpNetworkHelper[19410:486008] 任務2線程: <NSThread: 0x600000888000>{number = 3, name = (null)}
2019-08-19 10:43:34.192766+0800 XKHttpNetworkHelper[19410:486008] 任務2線程: <NSThread: 0x600000888000>{number = 3, name = (null)}
2019-08-19 10:43:34.192766+0800 XKHttpNetworkHelper[19410:486006] 任務1線程: <NSThread: 0x600000885400>{number = 4, name = (null)}
2019-08-19 10:43:36.193189+0800 XKHttpNetworkHelper[19410:485864] 主線程: <NSThread: 0x6000008fe3c0>{number = 1, name = main}
2019-08-19 10:43:38.193421+0800 XKHttpNetworkHelper[19410:485864] 主線程: <NSThread: 0x6000008fe3c0>{number = 1, name = main}
2019-08-19 10:43:38.193560+0800 XKHttpNetworkHelper[19410:485864] asyncGroupEnterAndLeaveTask : end
複製代碼

從執行任務的輸出日誌中能夠看到:

當全部任務執行完成以後，才執行 dispatch_group_notify 中的任務。這裏的dispatch_group_enter、dispatch_group_leave組合，其實等同於dispatch_group_async
複製代碼

6.6 信號量: dispatch_semaphore

GCD 中的信號量是指 Dispatch Semaphore ，是持有計數的信號。相似於一個高速路收費站的欄杆。能夠經過時，打開欄杆，不能夠經過時，關閉欄杆。

在 Dispatch Semaphore 中，使用計數來完成這個功能，計數爲0時等待，不可經過。計數爲1或大於1時，計數減1且不等待，可經過。

Dispatch Semaphore 提供了三個函數:

1. dispatch_semaphore_create: 建立一個Semaphore並初始化信號的總量

2. dispatch_semaphore_signal: 發送一個信號，讓信號總量加1

3. dispatch_semaphore_wait: 可使總信號量減1，當信號總量爲0時，就會一直等待（阻塞所在線程），不然就能夠正常執行。
複製代碼

注意:

信號量的使用前提是：想清楚你須要處理哪一個線程等待（阻塞），又要哪一個線程繼續執行，而後使用信號量。
複製代碼

Dispatch Semaphore 在實際開發中主要用於：

1. 保持線程同步，將異步執行任務轉換爲同步執行任務
2. 保證線程安全，爲線程加鎖
複製代碼

6.6.1 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 實現線程同步，將異步執行任務轉換爲同步執行任務。

/**
 * 信號量 dispatch_semaphore
 */
- (void)asyncSemaphoreTask {
    NSLog(@"當前線程 : %@",[NSThread currentThread]);
    NSLog(@"asyncSemaphoreTask : begin");
    
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);


    __block NSInteger number = 0;
    dispatch_async(queue, ^{
        for (NSInteger index = 0; index < 2; index ++ ) {
            [NSThread sleepForTimeInterval:2];                    // 休眠2s，模擬耗時操做
            NSLog(@"任務1線程: %@",[NSThread currentThread]);      // 打印當前線程
        }
        
        number = 100;
        dispatch_semaphore_signal(semaphore);
    });
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    NSLog(@"asyncSemaphoreTask: end,number = %zd",number);
}

日誌輸出:

2019-08-19 11:20:40.118988+0800 XKHttpNetworkHelper[20027:564696] 當前線程 : <NSThread: 0x600001490cc0>{number = 1, name = main}
2019-08-19 11:20:40.119158+0800 XKHttpNetworkHelper[20027:564696] asyncSemaphoreTask : begin
2019-08-19 11:20:42.123825+0800 XKHttpNetworkHelper[20027:564811] 任務1線程: <NSThread: 0x6000014c2640>{number = 3, name = (null)}
2019-08-19 11:20:44.128749+0800 XKHttpNetworkHelper[20027:564811] 任務1線程: <NSThread: 0x6000014c2640>{number = 3, name = (null)}
2019-08-19 11:20:44.128909+0800 XKHttpNetworkHelper[20027:564696] asyncSemaphoreTask: end,number = 100
複製代碼

從執行任務的輸出日誌中能夠看到:

1. semaphore---end 是在執行完 number = 100; 以後纔打印的。並且輸出結果 number 爲 100。 這是由於異步執行不會作任何等待，能夠繼續執行任務。
    
2.異步執行將任務1追加到隊列以後，不作等待，接着執行dispatch_semaphore_wait方法。此時 semaphore == 0，當前線程進入等待狀態。
  而後，異步任務1開始執行。任務1執行到dispatch_semaphore_signal以後，總信號量，此時 semaphore == 1，dispatch_semaphore_wait方法使總信號量減1，
  正在被阻塞的線程（主線程）恢復繼續執行。

3. 最後打印 asyncSemaphoreTask: end,number = 100。這樣就實現了線程同步，將異步執行任務轉換爲同步執行任務。
複製代碼

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

線程安全:

1. 若是你的代碼所在的進程中有多個線程在同時運行，而這些線程可能會同時運行這段代碼。若是每次運行結果和單線程運行的結果是同樣的，並且其餘的變量的值也和預期的是同樣的，就是線程安全的。

2. 若每一個線程中對全局變量、靜態變量只有讀操做，而無寫操做，通常來講，這個全局變量是線程安全的；如有多個線程同時執行寫操做（更改變量），通常都須要考慮線程同步，不然的話就可能影響線程安全。
複製代碼

線程同步:

可理解爲線程 A 和 線程 B 一塊配合，A 執行到必定程度時要依靠線程 B 的某個結果，因而停下來，示意 B 運行；B 依言執行，再將結果給 A；A 再繼續操做。

舉個簡單例子就是：兩我的在一塊兒聊天。兩我的不能同時說話，避免聽不清(操做衝突)。等一我的說完(一個線程結束操做)，另外一個再說(另外一個線程再開始操做)。
複製代碼

場景模擬:

模擬火車票售賣的方式，實現 NSThread 線程安全和解決線程同步問題

需求：總共有50張火車票，有兩個售賣火車票的窗口，一個是北京火車票售賣窗口，另外一個是上海火車票售賣窗口。兩個窗口同時售賣火車票，賣完爲止。
複製代碼

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

/**
 * 非線程安全：不使用 semaphore
 * 初始化火車票數量、賣票窗口(非線程安全)、並開始賣票
 */
- (void)initTicketStatusNotSafeTask{
    NSLog(@"當前線程 : %@",[NSThread currentThread]);
    NSLog(@"initTicketStatusNotSafeTask : begin");
    
    self.ticketSurplusCount = 10;
    
    // queue1 表明北京火車票售賣窗口
    dispatch_queue_t queue1 = dispatch_queue_create("net.gcd.testQueue1", DISPATCH_QUEUE_SERIAL);
    // queue2 表明上海火車票售賣窗口
    dispatch_queue_t queue2 = dispatch_queue_create("net.gcd.testQueue2", DISPATCH_QUEUE_SERIAL);

    __weak typeof(self) ws = self;
    dispatch_async(queue1, ^{
        [ws saleTicketNotSafeTask];
    });
    
    dispatch_async(queue2, ^{
        [ws saleTicketNotSafeTask];
    });
}

/**
 * 售賣火車票(非線程安全)
 */
- (void)saleTicketNotSafeTask {
    while (1) {
        if (self.ticketSurplusCount > 0) { //若是還有票，繼續售賣
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩餘票數：%ld 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        }else{ //若是已賣完，關閉售票窗口
            NSLog(@"全部火車票均已售完");
            break;
        }
    }
}

日誌輸出:

2019-08-19 11:53:16.220078+0800 XKHttpNetworkHelper[20418:614512] 當前線程 : <NSThread: 0x600002caa940>{number = 1, name = main}
2019-08-19 11:53:16.220223+0800 XKHttpNetworkHelper[20418:614512] initTicketStatusNotSafeTask : begin
2019-08-19 11:53:16.220462+0800 XKHttpNetworkHelper[20418:614556] 剩餘票數：8 窗口：<NSThread: 0x600002cf50c0>{number = 4, name = (null)}
2019-08-19 11:53:16.220498+0800 XKHttpNetworkHelper[20418:614561] 剩餘票數：9 窗口：<NSThread: 0x600002cc3d40>{number = 3, name = (null)}
2019-08-19 11:53:16.423119+0800 XKHttpNetworkHelper[20418:614556] 剩餘票數：6 窗口：<NSThread: 0x600002cf50c0>{number = 4, name = (null)}
2019-08-19 11:53:16.423124+0800 XKHttpNetworkHelper[20418:614561] 剩餘票數：7 窗口：<NSThread: 0x600002cc3d40>{number = 3, name = (null)}
2019-08-19 11:53:16.627985+0800 XKHttpNetworkHelper[20418:614561] 剩餘票數：4 窗口：<NSThread: 0x600002cc3d40>{number = 3, name = (null)}
2019-08-19 11:53:16.627986+0800 XKHttpNetworkHelper[20418:614556] 剩餘票數：5 窗口：<NSThread: 0x600002cf50c0>{number = 4, name = (null)}
2019-08-19 11:53:16.828705+0800 XKHttpNetworkHelper[20418:614556] 剩餘票數：3 窗口：<NSThread: 0x600002cf50c0>{number = 4, name = (null)}
2019-08-19 11:53:16.828705+0800 XKHttpNetworkHelper[20418:614561] 剩餘票數：2 窗口：<NSThread: 0x600002cc3d40>{number = 3, name = (null)}
2019-08-19 11:53:17.030931+0800 XKHttpNetworkHelper[20418:614556] 剩餘票數：1 窗口：<NSThread: 0x600002cf50c0>{number = 4, name = (null)}
2019-08-19 11:53:17.030943+0800 XKHttpNetworkHelper[20418:614561] 剩餘票數：1 窗口：<NSThread: 0x600002cc3d40>{number = 3, name = (null)}
2019-08-19 11:53:17.232633+0800 XKHttpNetworkHelper[20418:614556] 剩餘票數：0 窗口：<NSThread: 0x600002cf50c0>{number = 4, name = (null)}
2019-08-19 11:53:17.232645+0800 XKHttpNetworkHelper[20418:614561] 剩餘票數：0 窗口：<NSThread: 0x600002cc3d40>{number = 3, name = (null)}
2019-08-19 11:53:17.434801+0800 XKHttpNetworkHelper[20418:614556] 全部火車票均已售完
2019-08-19 11:53:17.434811+0800 XKHttpNetworkHelper[20418:614561] 全部火車票均已售完
複製代碼

從執行任務的輸出日誌中能夠看到:

在不考慮線程安全，不使用 semaphore 的狀況下，獲得票數是錯亂的，這樣顯然不符合咱們的需求，因此咱們須要考慮線程安全問題。
複製代碼

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

/**
 * 線程安全：使用 semaphore 加鎖
 * 初始化火車票數量、賣票窗口(線程安全)、並開始賣票
 */
- (void)initTicketStatusSafeTask{
    NSLog(@"當前線程 : %@",[NSThread currentThread]);
    NSLog(@"initTicketStatusNotSafeTask : begin");
    
    self.semaphoreLock = dispatch_semaphore_create(1);
    
    self.ticketSurplusCount = 10;
    
    // queue1 表明北京火車票售賣窗口
    dispatch_queue_t queue1 = dispatch_queue_create("net.gcd.testQueue1", DISPATCH_QUEUE_SERIAL);
    // queue2 表明上海火車票售賣窗口
    dispatch_queue_t queue2 = dispatch_queue_create("net.gcd.testQueue2", DISPATCH_QUEUE_SERIAL);

    __weak typeof(self) ws = self;
    dispatch_async(queue1, ^{
        [ws saleTicketSafeTask];
    });
    
    dispatch_async(queue2, ^{
        [ws saleTicketSafeTask];
    });
}

/**
 * 售賣火車票(線程安全)
 */
- (void)saleTicketSafeTask {
    while (1) {
        // 至關於加鎖
        dispatch_semaphore_wait(self.semaphoreLock, DISPATCH_TIME_FOREVER);
        
        if (self.ticketSurplusCount > 0) { //若是還有票，繼續售賣
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩餘票數：%ld 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
            
        }else{ //若是已賣完，關閉售票窗口
            NSLog(@"全部火車票均已售完");
            
            // 至關於解鎖
            dispatch_semaphore_signal(self.semaphoreLock);
            break;
        }
        // 至關於解鎖
        dispatch_semaphore_signal(self.semaphoreLock);
    }
}

日誌輸出:

2019-08-19 12:02:25.846200+0800 XKHttpNetworkHelper[20593:640200] 當前線程 : <NSThread: 0x600003ed2900>{number = 1, name = main}
2019-08-19 12:02:25.846374+0800 XKHttpNetworkHelper[20593:640200] initTicketStatusNotSafeTask : begin
2019-08-19 12:02:25.846739+0800 XKHttpNetworkHelper[20593:640300] 剩餘票數：9 窗口：<NSThread: 0x600003e8c700>{number = 3, name = (null)}
2019-08-19 12:02:26.051095+0800 XKHttpNetworkHelper[20593:640302] 剩餘票數：8 窗口：<NSThread: 0x600003ede500>{number = 4, name = (null)}
2019-08-19 12:02:26.256409+0800 XKHttpNetworkHelper[20593:640300] 剩餘票數：7 窗口：<NSThread: 0x600003e8c700>{number = 3, name = (null)}
2019-08-19 12:02:26.459732+0800 XKHttpNetworkHelper[20593:640302] 剩餘票數：6 窗口：<NSThread: 0x600003ede500>{number = 4, name = (null)}
2019-08-19 12:02:26.664534+0800 XKHttpNetworkHelper[20593:640300] 剩餘票數：5 窗口：<NSThread: 0x600003e8c700>{number = 3, name = (null)}
2019-08-19 12:02:26.869298+0800 XKHttpNetworkHelper[20593:640302] 剩餘票數：4 窗口：<NSThread: 0x600003ede500>{number = 4, name = (null)}
2019-08-19 12:02:27.073980+0800 XKHttpNetworkHelper[20593:640300] 剩餘票數：3 窗口：<NSThread: 0x600003e8c700>{number = 3, name = (null)}
2019-08-19 12:02:27.278409+0800 XKHttpNetworkHelper[20593:640302] 剩餘票數：2 窗口：<NSThread: 0x600003ede500>{number = 4, name = (null)}
2019-08-19 12:02:27.480733+0800 XKHttpNetworkHelper[20593:640300] 剩餘票數：1 窗口：<NSThread: 0x600003e8c700>{number = 3, name = (null)}
2019-08-19 12:02:27.683954+0800 XKHttpNetworkHelper[20593:640302] 剩餘票數：0 窗口：<NSThread: 0x600003ede500>{number = 4, name = (null)}
2019-08-19 12:02:27.887163+0800 XKHttpNetworkHelper[20593:640300] 全部火車票均已售完
2019-08-19 12:02:27.887329+0800 XKHttpNetworkHelper[20593:640302] 全部火車票均已售完
複製代碼

從執行任務的輸出日誌中能夠看到:

在考慮了線程安全的狀況下，使用 dispatch_semaphore 機制以後，獲得的票數是正確的，沒有出現混亂的狀況。
複製代碼

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。