繼上一篇說到的NSTread之后 本文主要分享下GCD的一些總結(jié)主要是按一下幾點(diǎn)進(jìn)行：

• GCD是什么?
• GCD任務(wù)和隊(duì)列
• GCD創(chuàng)建和使用
• GCD 線程間的通信
• GCD常見問題以及解決

GCD是什么昌讲？

來一張官網(wǎng)的截圖：

image.png

翻譯：Grand Central Dispatch（GCD）包括語言功能吠架，運(yùn)行時庫和系統(tǒng)增強(qiáng)功能娘扩，可為macOS泼差，iOS乐埠，watchOS和tvOS中多核硬件上的并發(fā)代碼執(zhí)行提供系統(tǒng)精堕，全面的改進(jìn)

GCD意思就是 ‘強(qiáng)大的中央調(diào)度器’

GCD的優(yōu)點(diǎn)：

• GCD 可用于多核的并行運(yùn)算
• GCD 會自動利用更多的 CPU 內(nèi)核
• GCD 會自動管理線程的生命周期（創(chuàng)建線程即寒、調(diào)度任務(wù)姨蟋、銷毀線程）
• 只需要告訴 GCD 想要執(zhí)行什么任務(wù)报辱，不需要編寫任何線程管理代碼

GCD 任務(wù)和隊(duì)列

任務(wù):

就是執(zhí)行操作的意思与殃，換句話說就是你在線程中執(zhí)行的那段代碼。在 GCD 中是放在 block 中的碍现。執(zhí)行任務(wù)有兩種方式：

• 同步執(zhí)行（sync）

  • 同步添加任務(wù)到指定的隊(duì)列中幅疼，在添加的任務(wù)執(zhí)行結(jié)束之前，會一直等待鸵赫，直到隊(duì)列里面的任務(wù)完成之后再繼續(xù)執(zhí)行衣屏。
    只能在當(dāng)前線程中執(zhí)行任務(wù)，不具備開啟新線程的能力辩棒。

• 異步執(zhí)行（async）

  • 異步添加任務(wù)到指定的隊(duì)列中狼忱，它不會做任何等待膨疏，可以繼續(xù)執(zhí)行任務(wù)。
    可以在新的線程中執(zhí)行任務(wù)钻弄，具備開啟新線程的能力佃却。

注意：是否等待隊(duì)列的任務(wù)執(zhí)行結(jié)束，以及是否具備開啟新線程的能力

隊(duì)列

在 GCD 中有兩種隊(duì)列：串行隊(duì)列和并發(fā)隊(duì)列窘俺。兩者都符合 FIFO（先進(jìn)先出）的原則饲帅。兩者的主要區(qū)別是：執(zhí)行順序不同，以及開啟線程數(shù)不同

• 串行隊(duì)列

  • 每次只有一個任務(wù)被執(zhí)行瘤泪。讓任務(wù)一個接著一個地執(zhí)行灶泵。一個任務(wù)執(zhí)行完畢后，再執(zhí)行下一個任務(wù)对途。

  • 只開啟一個新線程（或者不開啟新線程赦邻，在當(dāng)前線程執(zhí)行任務(wù)）。

• 并發(fā)隊(duì)列

  • 可以讓多個任務(wù)并發(fā)（同時）執(zhí)行实檀。
  • 可以開啟多個線程惶洲，并且同時執(zhí)行任務(wù)。

注意：并發(fā)隊(duì)列的并發(fā)功能只有在異步（dispatch_async）函數(shù)下才有效

串行隊(duì)列

并發(fā)隊(duì)列

GCD創(chuàng)建和使用

可以用dispatch_queue_create來創(chuàng)建 第一個參數(shù)是標(biāo)識膳犹，第二個參數(shù)是隊(duì)列類型分別是：DISPATCH_QUEUE_SERIAL 和 DISPATCH_QUEUE_CONCURRENT
SERIAL的中文意思是 串行
CONCURRENT 的中文意思是并發(fā)
這樣就好好理解了

// 串行隊(duì)列的創(chuàng)建方法
dispatch_queue_t queue = dispatch_queue_create("JFTestQueue", DISPATCH_QUEUE_SERIAL);
// 并發(fā)隊(duì)列的創(chuàng)建方法
dispatch_queue_t queue = dispatch_queue_create("JFTestQueue", DISPATCH_QUEUE_CONCURRENT);

串行隊(duì)列又有一個隊(duì)列：

• 主隊(duì)列

所有放在主隊(duì)列中的任務(wù)恬吕，都會放到主線程中執(zhí)行

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

并發(fā)隊(duì)列又有一個隊(duì)列：

• 全局并發(fā)隊(duì)列

可以使用dispatch_get_global_queue來獲取。需要傳入兩個參數(shù)须床。第一個參數(shù)表示隊(duì)列優(yōu)先級铐料，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二個參數(shù)暫時沒用侨颈，用0即可

// 全局并發(fā)隊(duì)列的獲取方法
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

任務(wù)的創(chuàng)建

GCD 提供了同步執(zhí)行任務(wù)的創(chuàng)建方法dispatch_sync和異步執(zhí)行任務(wù)創(chuàng)建方法dispatch_async

// 同步執(zhí)行任務(wù)創(chuàng)建方法
dispatch_sync(queue, ^{
    // 這里放同步執(zhí)行任務(wù)代碼
});
// 異步執(zhí)行任務(wù)創(chuàng)建方法
dispatch_async(queue, ^{
    // 這里放異步執(zhí)行任務(wù)代碼
});

好了現(xiàn)在 幾種隊(duì)列已經(jīng)知道了余赢，幾種執(zhí)行方式也知道了。那么他們之間的排列組合分別是：

• 同步執(zhí)行 + 并發(fā)隊(duì)列
• 異步執(zhí)行 + 并發(fā)隊(duì)列
• 同步執(zhí)行 + 串行隊(duì)列
• 異步執(zhí)行 + 串行隊(duì)列
• 同步執(zhí)行 + 主隊(duì)列

• 異步執(zhí)行 + 主隊(duì)列
  以下是同步異步隊(duì)列的關(guān)系

  
  
  image.png

接下里我們一個組合一個組合來看下：

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

/**
 * 同步執(zhí)行 + 并發(fā)隊(duì)列
 * 特點(diǎn)：在當(dāng)前線程中執(zhí)行任務(wù)哈垢，不會開啟新線程妻柒，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)耘分。
 */
- (void)syncConcurrent {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    NSLog(@"syncConcurrent---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("JFTestQueue", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_sync(queue, ^{
        // 追加任務(wù)1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    dispatch_sync(queue, ^{
        // 追加任務(wù)2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    dispatch_sync(queue, ^{
        // 追加任務(wù)3
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    NSLog(@"syncConcurrent---end");
}

image.png

打印如上：都在同一個線程中執(zhí)行举塔，且是執(zhí)行完一個任務(wù)后再執(zhí)行另一個任務(wù)

異步執(zhí)行 + 并發(fā)隊(duì)列

/**
/**
 * 異步執(zhí)行 + 并發(fā)隊(duì)列
 * 特點(diǎn)：可以開啟多個線程，任務(wù)交替（同時）執(zhí)行求泰。
 */
- (void)asyncConcurrent {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    NSLog(@"asyncConcurrent---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("JFTestQueue", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(queue, ^{
        // 追加任務(wù)1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    dispatch_async(queue, ^{
        // 追加任務(wù)2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    dispatch_async(queue, ^{
        // 追加任務(wù)3
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    NSLog(@"asyncConcurrent---end");
}

image.png

打印如上同時開啟多個線程且是無序的

除了當(dāng)前線程（主線程）央渣，系統(tǒng)又開啟了3個線程，并且任務(wù)是交替/同時執(zhí)行的渴频。（異步執(zhí)行具備開啟新線程的能力芽丹。且并發(fā)隊(duì)列可開啟多個線程，同時執(zhí)行多個任務(wù)）卜朗。
所有任務(wù)是在打印的syncConcurrent---begin和syncConcurrent---end之后才執(zhí)行的拔第。說明當(dāng)前線程沒有等待咕村，而是直接開啟了新線程，在新線程中執(zhí)行任務(wù)（異步執(zhí)行不做等待蚊俺，可以繼續(xù)執(zhí)行任務(wù)）懈涛。

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

/**
 * 同步執(zhí)行 + 串行隊(duì)列
 * 特點(diǎn)：不會開啟新線程，在當(dāng)前線程執(zhí)行任務(wù)泳猬。任務(wù)是串行的批钠，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)得封。
 */
- (void)syncSerial {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    NSLog(@"syncSerial---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("JFTestQueue", DISPATCH_QUEUE_SERIAL);
    
    dispatch_sync(queue, ^{
        // 追加任務(wù)1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    dispatch_sync(queue, ^{
        // 追加任務(wù)2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    dispatch_sync(queue, ^{
        // 追加任務(wù)3
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    NSLog(@"syncSerial---end");
}

image.png

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

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

/**
 * 異步執(zhí)行 + 串行隊(duì)列
 * 特點(diǎn)：會開啟新線程晨横，但是因?yàn)槿蝿?wù)是串行的，執(zhí)行完一個任務(wù)箫柳，再執(zhí)行下一個任務(wù)手形。
 */
- (void)asyncSerial {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    NSLog(@"asyncSerial---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("JFTestQueue", DISPATCH_QUEUE_SERIAL);
    
    dispatch_async(queue, ^{
        // 追加任務(wù)1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    dispatch_async(queue, ^{
        // 追加任務(wù)2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    dispatch_async(queue, ^{
        // 追加任務(wù)3
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    NSLog(@"asyncSerial---end");
}

image.png

• 開啟了一條新線程（異步執(zhí)行具備開啟新線程的能力，串行隊(duì)列只開啟一個線程）悯恍。
• 所有任務(wù)是在打印的syncConcurrent---begin和syncConcurrent---end之后才開始執(zhí)行的（異步執(zhí)行不會做任何等待库糠，可以繼續(xù)執(zhí)行任務(wù)）。
• 任務(wù)是按順序執(zhí)行的（串行隊(duì)列每次只有一個任務(wù)被執(zhí)行涮毫，任務(wù)一個接一個按順序執(zhí)行）瞬欧。

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

同步執(zhí)行 + 主隊(duì)列 主線程

/**
 * 同步執(zhí)行 + 主隊(duì)列
 * 特點(diǎn)(主線程調(diào)用)：互等卡主不執(zhí)行。
 * 特點(diǎn)(其他線程調(diào)用)：不會開啟新線程罢防，執(zhí)行完一個任務(wù)艘虎，再執(zhí)行下一個任務(wù)。
 */
- (void)syncMain {
    
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    NSLog(@"syncMain---begin");
    
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    dispatch_sync(queue, ^{
        // 追加任務(wù)1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    dispatch_sync(queue, ^{
        // 追加任務(wù)2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    dispatch_sync(queue, ^{
        // 追加任務(wù)3
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    NSLog(@"syncMain---end");
}

image.png

image.png

打印和運(yùn)行如上截圖 奔潰了

在主線程中使用同步執(zhí)行 + 主隊(duì)列咒吐，追加到主線程的任務(wù)1野建、任務(wù)2、任務(wù)3都不再執(zhí)行了恬叹，而且syncMain---end也沒有打印候生，在XCode 9上還會報(bào)崩潰。這是為什么呢?

這是因?yàn)槲覀冊谥骶€程中執(zhí)行syncMain方法绽昼，相當(dāng)于把syncMain任務(wù)放到了主線程的隊(duì)列中唯鸭。而同步執(zhí)行會等待當(dāng)前隊(duì)列中的任務(wù)執(zhí)行完畢，才會接著執(zhí)行硅确。那么當(dāng)我們把任務(wù)1追加到主隊(duì)列中目溉，任務(wù)1就在等待主線程處理完syncMain任務(wù)明肮。而syncMain任務(wù)需要等待任務(wù)1執(zhí)行完畢，才能接著執(zhí)行停做。

那么晤愧，現(xiàn)在的情況就是syncMain任務(wù)和任務(wù)1都在等對方執(zhí)行完畢。這樣大家互相等待蛉腌，所以就卡住了官份，所以我們的任務(wù)執(zhí)行不了，而且syncMain---end也沒有打印

在其他線程中調(diào)用 同步執(zhí)行 + 主隊(duì)列 在其他線程

    // 使用 NSThread 的 detachNewThreadSelector 方法會創(chuàng)建線程烙丛，并自動啟動線程執(zhí)行
//    selector 任務(wù)
    [NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];

image.png

為什么現(xiàn)在就不會卡住了呢舅巷？
因?yàn)閟yncMain 任務(wù)放到了其他線程里，而任務(wù)1河咽、任務(wù)2钠右、任務(wù)3都在追加到主隊(duì)列中，這三個任務(wù)都會在主線程中執(zhí)行忘蟹。syncMain 任務(wù)在其他線程中執(zhí)行到追加任務(wù)1到主隊(duì)列中飒房，因?yàn)橹麝?duì)列現(xiàn)在沒有正在執(zhí)行的任務(wù)，所以媚值，會直接執(zhí)行主隊(duì)列的任務(wù)1狠毯，等任務(wù)1執(zhí)行完畢，再接著執(zhí)行任務(wù)2褥芒、任務(wù)3嚼松。所以這里不會卡住線程

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

 NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    NSLog(@"asyncMain---begin");
    
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    dispatch_async(queue, ^{
        // 追加任務(wù)1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    dispatch_async(queue, ^{
        // 追加任務(wù)2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    dispatch_async(queue, ^{
        // 追加任務(wù)3
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    NSLog(@"asyncMain---end");
}

image.png

打印如上

• 所有任務(wù)都是在當(dāng)前線程（主線程）中執(zhí)行的，并沒有開啟新的線程（雖然異步執(zhí)行具備開啟線程的能力锰扶，但因?yàn)槭侵麝?duì)列献酗，所以所有任務(wù)都在主線程中）。
• 所有任務(wù)是在打印的syncConcurrent—-begin和syncConcurrent—-end之后才開始執(zhí)行的（異步執(zhí)行不會做任何等待坷牛，可以繼續(xù)執(zhí)行任務(wù)）罕偎。
• 任務(wù)是按順序執(zhí)行的（因?yàn)橹麝?duì)列是串行隊(duì)列，每次只有一個任務(wù)被執(zhí)行京闰，任務(wù)一個接一個按順序執(zhí)行）锨亏。

GCD 柵欄方法

我們有時需要異步執(zhí)行兩組操作，而且第一組操作執(zhí)行完之后忙干，才能開始執(zhí)行第二組操作器予。這樣我們就需要一個相當(dāng)于柵欄一樣的一個方法將兩組異步執(zhí)行的操作組給分割起來，當(dāng)然這里的操作組里可以包含一個或多個任務(wù)捐迫。這就需要用到dispatch_barrier_async方法在兩個操作組間形成柵欄乾翔。
dispatch_barrier_async函數(shù)會等待前邊追加到并發(fā)隊(duì)列中的任務(wù)全部執(zhí)行完畢之后，再將指定的任務(wù)追加到該異步隊(duì)列中。然后在dispatch_barrier_async函數(shù)追加的任務(wù)執(zhí)行完畢之后反浓，異步隊(duì)列才恢復(fù)為一般動作萌丈，接著追加任務(wù)到該異步隊(duì)列并開始執(zhí)行

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

image.png

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

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

/**
 * 延時執(zhí)行方法 dispatch_after
 */
- (void)after {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    NSLog(@"asyncMain---begin");
    
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        // 2.0秒后異步追加任務(wù)代碼到主隊(duì)列而姐，并開始執(zhí)行
        NSLog(@"after---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    });
}

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

/**
 * 一次性代碼（只執(zhí)行一次）dispatch_once
 */
- (void)once {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        // 只執(zhí)行1次的代碼(這里面默認(rèn)是線程安全的)
    });
}

GCD 快速迭代方法：dispatch_apply

/**
 * 快速迭代方法 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");
}

image.png

• 調(diào)用隊(duì)列組的 dispatch_group_async 先把任務(wù)放到隊(duì)列中划煮，然后將隊(duì)列放入隊(duì)列組中〉薅恚或者使用隊(duì)列組的 dispatch_group_enter、dispatch_group_leave 組合 來實(shí)現(xiàn)
  dispatch_group_async器躏。
• 調(diào)用隊(duì)列組的 dispatch_group_notify 回到指定線程執(zhí)行任務(wù)俐载。或者使用 dispatch_group_wait 回到當(dāng)前線程繼續(xù)向下執(zhí)行（會阻塞當(dāng)前線程）登失。
  dispatch_group_notify

/**
 * 隊(duì)列組 dispatch_group_notify
 */
- (void)groupNotify {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    NSLog(@"group---begin");
    
    dispatch_group_t group =  dispatch_group_create();
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任務(wù)1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任務(wù)2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的異步任務(wù)1遏佣、任務(wù)2都執(zhí)行完畢后，回到主線程執(zhí)行下邊任務(wù)
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
        NSLog(@"group---end");
    });
}

image.png

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

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

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

image.png

dispatch_group_enter膛虫、dispatch_group_leave
dispatch_group_enter、dispatch_group_leave

• dispatch_group_enter 標(biāo)志著一個任務(wù)追加到 group钓猬，執(zhí)行一次稍刀，相當(dāng)于 group 中未執(zhí)行完畢任務(wù)數(shù)+1
• dispatch_group_leave 標(biāo)志著一個任務(wù)離開了 group，執(zhí)行一次，相當(dāng)于 group 中未執(zhí)行完畢任務(wù)數(shù)-1账月。
• 當(dāng) group 中未執(zhí)行完畢任務(wù)數(shù)為0的時候综膀，才會使dispatch_group_wait解除阻塞，以及執(zhí)行追加到dispatch_group_notify中的任務(wù)局齿。

/**
 * 隊(duì)列組 dispatch_group_enter剧劝、dispatch_group_leave
 */
- (void)groupEnterAndLeave
{
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    NSLog(@"group---begin");
    
    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        // 追加任務(wù)1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
        dispatch_group_leave(group);
    });
    
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        // 追加任務(wù)2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
        dispatch_group_leave(group);
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的異步操作都執(zhí)行完畢后，回到主線程.
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
        NSLog(@"group---end");
    });
    
//    // 等待上面的任務(wù)全部完成后抓歼，會往下繼續(xù)執(zhí)行（會阻塞當(dāng)前線程）
//    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
//
//    NSLog(@"group---end");
}

image.png

GCD 信號量：dispatch_semaphore
GCD 中的信號量是指 Dispatch Semaphore拌禾，是持有計(jì)數(shù)的信號取胎。類似于過高速路收費(fèi)站的欄桿∨惹希可以通過時闻蛀，打開欄桿，不可以通過時您市，關(guān)閉欄桿觉痛。在 Dispatch Semaphore 中，使用計(jì)數(shù)來完成這個功能茵休，計(jì)數(shù)為0時等待薪棒，不可通過。計(jì)數(shù)為1或大于1時榕莺，計(jì)數(shù)減1且不等待俐芯，可通過。
Dispatch Semaphore 提供了三個函數(shù)钉鸯。

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

注意：信號量的使用前提是：想清楚你需要處理哪個線程等待（阻塞），又要哪個線程繼續(xù)執(zhí)行岩睁，然后使用信號量
Dispatch Semaphore 在實(shí)際開發(fā)中主要用于：

• 保持線程同步钞脂，將異步執(zhí)行任務(wù)轉(zhuǎn)換為同步執(zhí)行任務(wù)

• 保證線程安全，為線程加鎖

  
  
  image.png

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

/**
 * 非線程安全：不使用 semaphore
 * 初始化彩票數(shù)量捕儒、賣票窗口(非線程安全)芳肌、并開始賣票
 */
- (void)initTicketStatusNotSave {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    NSLog(@"semaphore---begin");
    
    self.ticketSurplusCount = 50;
    
    // queue1 代表籃球票票售賣窗口
    dispatch_queue_t queue1 = dispatch_queue_create("JFTestQueue1", DISPATCH_QUEUE_SERIAL);
    // queue2 代表足球票售賣窗口
    dispatch_queue_t queue2 = dispatch_queue_create("JFTestQueue1", DISPATCH_QUEUE_SERIAL);
    
    __weak typeof(self) weakSelf = self;
    dispatch_async(queue1, ^{
        [weakSelf saleTicketNotSafe];
    });
    
    dispatch_async(queue2, ^{
        [weakSelf saleTicketNotSafe];
    });
}

/**
 * 彩票(非線程安全)
 */
- (void)saleTicketNotSafe {
    while (1) {
        
        if (self.ticketSurplusCount > 0) {  //如果還有票，繼續(xù)售賣
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩余票數(shù)：%d 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        } else { //如果已賣完，關(guān)閉售票窗口
            NSLog(@"所有彩票均已售完");
            break;
        }
        
    }
}

image.png

打印如上：數(shù)據(jù)是錯亂的

線程安全（使用 semaphore 加鎖）

/**
 * 線程安全：使用 semaphore 加鎖
 * 初始化彩票數(shù)量亿笤、賣票窗口(線程安全)翎迁、并開始賣票
 */
- (void)initTicketStatusSave {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    NSLog(@"semaphore---begin");
    
    semaphoreLock = dispatch_semaphore_create(1);
    
    self.ticketSurplusCount = 50;
    
    // queue1 代表籃球彩票票售賣窗口
    dispatch_queue_t queue1 = dispatch_queue_create("JFTestestQueue1", DISPATCH_QUEUE_SERIAL);
    // queue2 代表足球彩票售賣窗口
    dispatch_queue_t queue2 = dispatch_queue_create("JFTestestQueue2", DISPATCH_QUEUE_SERIAL);
    
    __weak typeof(self) weakSelf = self;
    dispatch_async(queue1, ^{
        [weakSelf saleTicketSafe];
    });
    
    dispatch_async(queue2, ^{
        [weakSelf saleTicketSafe];
    });
}

/**
 * 售賣火車票(線程安全)
 */
- (void)saleTicketSafe {
    while (1) {
        // 相當(dāng)于加鎖
        dispatch_semaphore_wait(semaphoreLock, DISPATCH_TIME_FOREVER);
        
        if (self.ticketSurplusCount > 0) {  //如果還有票，繼續(xù)售賣
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩余票數(shù)：%d 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        } else { //如果已賣完净薛，關(guān)閉售票窗口
            NSLog(@"所有彩均已售完");
            
            // 相當(dāng)于解鎖
            dispatch_semaphore_signal(semaphoreLock);
            break;
        }
        
        // 相當(dāng)于解鎖
        dispatch_semaphore_signal(semaphoreLock);
    }
}

image.png

打印如上枷鎖之后的數(shù)據(jù)就正常了

GCD常見問題以及解決

• 線程死鎖

死鎖原因：
所謂死鎖汪榔，通常指有兩個線程A和B都卡住了，并等待對方完成某些操作肃拜。A不能完成是因?yàn)樗诘却鼴完成痴腌。但B也不能完成，因?yàn)樗诘却鼳完成燃领。于是大家都完不成士聪，就導(dǎo)致了死鎖（DeadLock）。

死鎖的例子

   dispatch_sync(dispatch_get_main_queue(), ^(void){
            NSLog(@"這里死鎖了");
        });

dispatch_queue_t queue = dispatch_queue_create("me.tutuge.test.gcd", DISPATCH_QUEUE_SERIAL);

dispatch_apply(3, queue, ^(size_t i) {
    NSLog(@"apply loop: %zu", i);

    //再來一個dispatch_apply猛蔽！死鎖剥悟！
    dispatch_apply(3, queue, ^(size_t j) {
        NSLog(@"apply loop inside %zu", j);
    });
});

解決：

dispatch_async(dispatch_get_global_queue(0,0), ^(void){
    NSLog(@"這就不死鎖了");
});

dispatch_queue_t queue = dispatch_queue_create("serial", nil);
dispatch_sync(queue, ^(void){
    NSLog(@"這個也不會死鎖");
});

回顧下上面的表格：

image.png

同步主隊(duì)列導(dǎo)致線程死鎖

一定要避免dispatch_apply的嵌套調(diào)用。

• 線程不安全
  線程不安全是由于多線程訪問造成的
  解決：
  1.既然線程安全問題是由多線程引起的曼库，那么区岗，最極端的可以使用單線程保證線程安全。
  2.線程安全是由于多線程訪問和修改共享資源而引起不可預(yù)測的結(jié)果毁枯，因此慈缔，如果都是訪問共享資源而不去修改共享資源也可以保證線程安全，比如：設(shè)置只讀屬性的全局變量种玛。
  3.使用鎖藐鹤。（上面已經(jīng)說到了）

• dispatch_once_t必須是全局或static變量
  //靜態(tài)變量，保證只有一份實(shí)例赂韵，才能確保只執(zhí)行一次

• dispatch_after是延遲提交娱节，不是延遲運(yùn)行

Enqueue a block for execution at the specified time.

Enqueue，就是入隊(duì)右锨，指的就是將一個Block在特定的延時以后，加入到指定的隊(duì)列中碌秸，不是在特定的時間后立即運(yùn)行绍移！

• 如何正確創(chuàng)建dispatch_time_t

1. dispatch_time(<#dispatch_time_t when#>, <#int64_t delta#>)
        第一個參數(shù)是從什么時間開始,一般直接傳 DISPATCH_TIME_NOW; 表示從現(xiàn)在開始
        第二個參數(shù)表示具體的時間長度(不能直接傳 int 或 float), 可以寫成這種形式 (int64_t)3* NSEC_PER_SEC
        
        #define NSEC_PER_SEC 1000000000ull  每秒有1000000000納秒
        #define NSEC_PER_MSEC 1000000ull    每毫秒有1000000納秒
        #define USEC_PER_SEC 1000000ull     每秒有1000000微秒
        #define NSEC_PER_USEC 1000ull       每微秒有1000納秒
        
        注意 delta 的單位是納秒! 
        1秒的寫作方式可以是 1* NSEC_PER_SEC; 1000* NSEC_PER_MSEC; USEC_PER_SEC* NSEC_PER_USEC
     
2. dispatch_walltime(<#const struct timespec * _Nullable when#>, <#int64_t delta#>),
        第一個參數(shù)是一個結(jié)構(gòu)體, 創(chuàng)建的是一個絕對的時間點(diǎn),比如 2016年10月10日8點(diǎn)30分30秒, 如果你不需要自某一個特定的時刻開始,可以傳 NUll,表示自動獲取當(dāng)前時區(qū)的當(dāng)前時間作為開始時刻, 第二參數(shù)意義同第一個函數(shù)
        dispatch_time_t time = dispatch_walltime(NULL, 5* NSEC_PER_SEC);
        

參考：
https://bujige.net/blog/iOS-Complete-learning-pthread-and-NSThread.html
http://tutuge.me/2015/04/03/something-about-gcd/
注：本文參考如上兩篇文章，如造成商業(yè)侵權(quán)望告知讥电，并修改

demo地址：https://github.com/tubie/JFMultiThreading