本文用來介紹 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 鏈接：傳送門

1. GCD 簡介

什麼是 GCD 呢？我們先來看看百度百科的解釋簡單瞭解下概念

為什麼要用 GCD 呢？

因為 GCD 有很多好處啊，具體如下：

• GCD 可用於多核的並行運算
• GCD 會自動利用更多的 CPU 內核（比如雙核、四核）
• GCD 會自動管理線程的生命周期（創建線程、調度任務、銷毀線程）
• 程式員只需要告訴 GCD 想要執行什麼任務，不需要編寫任何線程管理代碼

2. GCD 任務和隊列

學習 GCD 之前，先來瞭解 GCD 中兩個核心概念：任務和隊列。

任務：就是執行操作的意思，換句話說就是你線上程中執行的那段代碼。在 GCD 中是放在 block 中的。執行任務有兩種方式：同步執行（sync）和非同步執行（async）。兩者的主要區別是：是否等待隊列的任務執行結束，以及是否具備開啟新線程的能力。

• 同步執行（sync）：
  • 同步添加任務到指定的隊列中，在添加的任務執行結束之前，會一直等待，直到隊列裡面的任務完成之後再繼續執行。
  • 只能在當前線程中執行任務，不具備開啟新線程的能力。
• 非同步執行（async）：
  • 非同步添加任務到指定的隊列中，它不會做任何等待，可以繼續執行任務。
  • 可以在新的線程中執行任務，具備開啟新線程的能力。

舉個簡單例子：你要打電話給小明和小白。
同步執行就是，你打電話給小明的時候，不能同時打給小白，等到給小明打完了，才能打給小白（等待任務執行結束）。而且只能用當前的電話（不具備開啟新線程的能力）。
而非同步執行就是，你打電話給小明的時候，不等和小明通話結束，還能直接給小白打電話，不用等著和小明通話結束再打（不用等待任務執行結束）。除了當前電話，你還可以使用其他所能使用的電話（具備開啟新線程的能力）。

註意：非同步執行（async）雖然具有開啟新線程的能力，但是並不一定開啟新線程。這跟任務所指定的隊列類型有關（下麵會講）。

隊列（Dispatch Queue）：這裡的隊列指執行任務的等待隊列，即用來存放任務的隊列。隊列是一種特殊的線性表，採用 FIFO（先進先出）的原則，即新任務總是被插入到隊列的末尾，而讀取任務的時候總是從隊列的頭部開始讀取。每讀取一個任務，則從隊列中釋放一個任務。隊列的結構可參考下圖：

在 GCD 中有兩種隊列：串列隊列和併發隊列。兩者都符合 FIFO（先進先出）的原則。兩者的主要區別是：執行順序不同，以及開啟線程數不同。

• 串列隊列（Serial Dispatch Queue）：
  • 每次只有一個任務被執行。讓任務一個接著一個地執行。（只開啟一個線程，一個任務執行完畢後，再執行下一個任務）
• 併發隊列（Concurrent Dispatch Queue）：
  • 可以讓多個任務併發（同時）執行。（可以開啟多個線程，並且同時執行任務）

註意：併發隊列的併發功能只有在非同步（dispatch_async）函數下才有效

兩者具體區別如下兩圖所示。

3. GCD 的使用步驟

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

1. 創建一個隊列（串列隊列或併發隊列）
2. 將任務追加到任務的等待隊列中，然後系統就會根據任務類型執行任務（同步執行或非同步執行）

下邊來看看隊列的創建方法/獲取方法，以及任務的創建方法。

3.1 隊列的創建方法/獲取方法

• 可以使用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);

3.2 任務的創建方法

GCD 提供了同步執行任務的創建方法dispatch_sync和非同步執行任務創建方法dispatch_async。

// 同步執行任務創建方法
dispatch_sync(queue, ^{
    // 這裡放同步執行任務代碼
});
// 非同步執行任務創建方法
dispatch_async(queue, ^{
    // 這裡放非同步執行任務代碼
});

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

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

實際上，剛纔還說了兩種特殊隊列：全局併發隊列、主隊列。全局併發隊列可以作為普通併發隊列來使用。但是主隊列因為有點特殊，所以我們就又多了兩種組合方式。這樣就有六種不同的組合方式了。

5. 同步執行 + 主隊列
6. 非同步執行 + 主隊列

那麼這幾種不同組合方式各有什麼區別呢，這裡為了方便，先上結果，再來講解。你可以直接查看表格結果，然後跳過 4. GCD的基本使用 。

下邊我們來分別講講這幾種不同的組合方式的使用方法。

4.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");
}

從同步執行 + 併發隊列中可看到：

• 所有任務都是在當前線程（主線程）中執行的，沒有開啟新的線程（同步執行不具備開啟新線程的能力）。
• 所有任務都在列印的syncConcurrent---begin和syncConcurrent---end之間執行的（同步任務需要等待隊列的任務執行結束）。
• 任務按順序執行的。按順序執行的原因：雖然併發隊列可以開啟多個線程，並且同時執行多個任務。但是因為本身不能創建新線程，只有當前線程這一個線程（同步任務不具備開啟新線程的能力），所以也就不存在併發。而且當前線程只有等待當前隊列中正在執行的任務執行完畢之後，才能繼續接著執行下麵的操作（同步任務需要等待隊列的任務執行結束）。所以任務只能一個接一個按順序執行，不能同時被執行。

4.2 非同步執行 + 併發隊列

• 可以開啟多個線程，任務交替（同時）執行。

/**
 * 非同步執行 + 併發隊列
 * 特點：可以開啟多個線程，任務交替（同時）執行。
 */
- (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");
}

在非同步執行 + 併發隊列中可以看出：

• 除了當前線程（主線程），系統又開啟了3個線程，並且任務是交替/同時執行的。（非同步執行具備開啟新線程的能力。且併發隊列可開啟多個線程，同時執行多個任務）。
• 所有任務是在列印的syncConcurrent---begin和syncConcurrent---end之後才執行的。說明當前線程沒有等待，而是直接開啟了新線程，在新線程中執行任務（非同步執行不做等待，可以繼續執行任務）。

接下來再來講講串列隊列的兩種執行方式。

4.3 同步執行 + 串列隊列

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

/**
 * 同步執行 + 串列隊列
 * 特點：不會開啟新線程，在當前線程執行任務。任務是串列的，執行完一個任務，再執行下一個任務。
 */
- (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");
}

在同步執行 + 串列隊列可以看到：

• 所有任務都是在當前線程（主線程）中執行的，並沒有開啟新的線程（同步執行不具備開啟新線程的能力）。
• 所有任務都在列印的syncConcurrent---begin和syncConcurrent---end之間執行（同步任務需要等待隊列的任務執行結束）。
• 任務是按順序執行的（串列隊列每次只有一個任務被執行，任務一個接一個按順序執行）。

4.4 非同步執行 + 串列隊列

• 會開啟新線程，但是因為任務是串列的，執行完一個任務，再執行下一個任務

/**
 * 非同步執行 + 串列隊列
 * 特點：會開啟新線程，但是因為任務是串列的，執行完一個任務，再執行下一個任務。
 */
- (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");
}

在非同步執行 + 串列隊列可以看到：

• 開啟了一條新線程（非同步執行具備開啟新線程的能力，串列隊列只開啟一個線程）。
• 所有任務是在列印的syncConcurrent---begin和syncConcurrent---end之後才開始執行的（非同步執行不會做任何等待，可以繼續執行任務）。
• 任務是按順序執行的（串列隊列每次只有一個任務被執行，任務一個接一個按順序執行）。

下邊講講剛纔我們提到過的特殊隊列：主隊列。

• 主隊列：GCD自帶的一種特殊的串列隊列
  • 所有放在主隊列中的任務，都會放到主線程中執行
  • 可使用dispatch_get_main_queue()獲得主隊列

我們再來看看主隊列的兩種組合方式。

4.5 同步執行 + 主隊列

同步執行 + 主隊列在不同線程中調用結果也是不一樣，在主線程中調用會出現死鎖，而在其他線程中則不會。

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

• 互相等待卡住不可行

/**
 * 同步執行 + 主隊列
 * 特點(主線程調用)：互等卡主不執行。
 * 特點(其他線程調用)：不會開啟新線程，執行完一個任務，再執行下一個任務。
 */
- (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");
}

在同步執行 + 主隊列可以驚奇的發現：

• 在主線程中使用同步執行 + 主隊列，追加到主線程的任務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:self withObject:nil];

在其他線程中使用同步執行 + 主隊列可看到：

• 所有任務都是在主線程（非當前線程）中執行的，沒有開啟新的線程（所有放在主隊列中的任務，都會放到主線程中執行）。
• 所有任務都在列印的syncConcurrent---begin和syncConcurrent---end之間執行（同步任務需要等待隊列的任務執行結束）。
• 任務是按順序執行的（主隊列是串列隊列，每次只有一個任務被執行，任務一個接一個按順序執行）。

為什麼現在就不會卡住了呢？
因為 syncMain 任務放到了其他線程里，而任務1、任務2、任務3都在追加到主隊列中，這三個任務都會在主線程中執行。syncMain 任務在其他線程中執行到追加任務1到主隊列中，因為主隊列現在沒有正在執行的任務，所以，會直接執行主隊列的任務1，等任務1執行完畢，再接著執行任務2、任務3。所以這裡不會卡住線程。

4.6 非同步執行 + 主隊列

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

/**
 * 非同步執行 + 主隊列
 * 特點：只在主線程中執行任務，執行完一個任務，再執行下一個任務
 */
- (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");
}

在非同步執行 + 主隊列可以看到：

• 所有任務都是在當前線程（主線程）中執行的，並沒有開啟新的線程（雖然非同步執行具備開啟線程的能力，但因為是主隊列，所以所有任務都在主線程中）。
• 所有任務是在列印的syncConcurrent---begin和syncConcurrent---end之後才開始執行的（非同步執行不會做任何等待，可以繼續執行任務）。
• 任務是按順序執行的（因為主隊列是串列隊列，每次只有一個任務被執行，任務一個接一個按順序執行）。

弄懂了難理解、繞來繞去的隊列+任務之後，我們來學習一個簡單的東西：5. GCD 線程間的通信。

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]);      // 列印當前線程
        });
    });
}

6. GCD 的其他方法

6.1 GCD 柵欄方法：dispatch_barrier_async

• 我們有時需要非同步執行兩組操作，而且第一組操作執行完之後，才能開始執行第二組操作。這樣我們就需要一個相當於柵欄一樣的一個方法將兩組非同步執行的操作組給分割起來，當然這裡的操作組裡可以包含一個或多個任務。這就需要用到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)