• 本文首發於我的個人部落格：『不羈閣』
• 文章連結：傳送門

本文用來介紹 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 呢？我們先來看看百度百科的解釋簡單瞭解下概念。

引自百度百科

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（先進先出）的原則，即新任務總是被插入到佇列的末尾，而讀取任務的時候總是從佇列的頭部開始讀取。每讀取一個任務，則從佇列中釋放一個任務。佇列的結構可參考下圖：

在 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 的基本使用 。

區別	併發佇列	序列佇列	主佇列
同步(sync)	沒有開啟新執行緒，序列執行任務	沒有開啟新執行緒，序列執行任務	沒有開啟新執行緒，序列執行任務
非同步(async)	有開啟新執行緒，併發執行任務	有開啟新執行緒(1條)，序列執行任務	沒有開啟新執行緒，序列執行任務

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

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");

  }複製程式碼

輸出結果：

2018-02-23 20:34:55.095932+0800 YSC-GCD-demo[19892:4996930] currentThread—<
NSThread: 0x60400006bbc0>
{number = 1, name = main
}

2018-02-23 20:34:55.096086+0800 YSC-GCD-demo[19892:4996930] syncConcurrent—begin

2018-02-23 20:34:57.097589+0800 YSC-GCD-demo[19892:4996930] 1—<
NSThread: 0x60400006bbc0>
{number = 1, name = main
}

2018-02-23 20:34:59.099100+0800 YSC-GCD-demo[19892:4996930] 1—<
NSThread: 0x60400006bbc0>
{number = 1, name = main
}

2018-02-23 20:35:01.099843+0800 YSC-GCD-demo[19892:4996930] 2—<
NSThread: 0x60400006bbc0>
{number = 1, name = main
}

2018-02-23 20:35:03.101171+0800 YSC-GCD-demo[19892:4996930] 2—<
NSThread: 0x60400006bbc0>
{number = 1, name = main
}

2018-02-23 20:35:05.101750+0800 YSC-GCD-demo[19892:4996930] 3—<
NSThread: 0x60400006bbc0>
{number = 1, name = main
}

2018-02-23 20:35:07.102414+0800 YSC-GCD-demo[19892:4996930] 3—<
NSThread: 0x60400006bbc0>
{number = 1, name = main
}

2018-02-23 20:35:07.102575+0800 YSC-GCD-demo[19892:4996930] syncConcurrent—end

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

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

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");

  }複製程式碼

輸出結果：

2018-02-23 20:36:41.769269+0800 YSC-GCD-demo[19929:5005237] currentThread—<
NSThread: 0x604000062d80>
{number = 1, name = main
}

2018-02-23 20:36:41.769496+0800 YSC-GCD-demo[19929:5005237] asyncConcurrent—begin

2018-02-23 20:36:41.769725+0800 YSC-GCD-demo[19929:5005237] asyncConcurrent—end

2018-02-23 20:36:43.774442+0800 YSC-GCD-demo[19929:5005566] 2—<
NSThread: 0x604000266f00>
{number = 5, name = (null)
}

2018-02-23 20:36:43.774440+0800 YSC-GCD-demo[19929:5005567] 3—<
NSThread: 0x60000026f200>
{number = 4, name = (null)
}

2018-02-23 20:36:43.774440+0800 YSC-GCD-demo[19929:5005565] 1—<
NSThread: 0x600000264800>
{number = 3, name = (null)
}

2018-02-23 20:36:45.779286+0800 YSC-GCD-demo[19929:5005567] 3—<
NSThread: 0x60000026f200>
{number = 4, name = (null)
}

2018-02-23 20:36:45.779302+0800 YSC-GCD-demo[19929:5005565] 1—<
NSThread: 0x600000264800>
{number = 3, name = (null)
}

2018-02-23 20:36:45.779286+0800 YSC-GCD-demo[19929:5005566] 2—<
NSThread: 0x604000266f00>
{number = 5, name = (null)
}

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

• 除了當前執行緒（主執行緒），系統又開啟了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");

  }複製程式碼

輸出結果：

2018-02-23 20:39:37.876811+0800 YSC-GCD-demo[19975:5017162] currentThread—<
NSThread: 0x604000079400>
{number = 1, name = main
}

2018-02-23 20:39:37.876998+0800 YSC-GCD-demo[19975:5017162] syncSerial—begin

2018-02-23 20:39:39.878316+0800 YSC-GCD-demo[19975:5017162] 1—<
NSThread: 0x604000079400>
{number = 1, name = main
}

2018-02-23 20:39:41.879829+0800 YSC-GCD-demo[19975:5017162] 1—<
NSThread: 0x604000079400>
{number = 1, name = main
}

2018-02-23 20:39:43.880660+0800 YSC-GCD-demo[19975:5017162] 2—<
NSThread: 0x604000079400>
{number = 1, name = main
}

2018-02-23 20:39:45.881265+0800 YSC-GCD-demo[19975:5017162] 2—<
NSThread: 0x604000079400>
{number = 1, name = main
}

2018-02-23 20:39:47.882257+0800 YSC-GCD-demo[19975:5017162] 3—<
NSThread: 0x604000079400>
{number = 1, name = main
}

2018-02-23 20:39:49.883008+0800 YSC-GCD-demo[19975:5017162] 3—<
NSThread: 0x604000079400>
{number = 1, name = main
}

2018-02-23 20:39:49.883253+0800 YSC-GCD-demo[19975:5017162] syncSerial—end

在同步執行 + 序列佇列可以看到：

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

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");

  }複製程式碼

輸出結果：

2018-02-23 20:41:17.029999+0800 YSC-GCD-demo[20008:5024757] currentThread—<
NSThread: 0x604000070440>
{number = 1, name = main
}

2018-02-23 20:41:17.030212+0800 YSC-GCD-demo[20008:5024757] asyncSerial—begin

2018-02-23 20:41:17.030364+0800 YSC-GCD-demo[20008:5024757] asyncSerial—end

2018-02-23 20:41:19.035379+0800 YSC-GCD-demo[20008:5024950] 1—<
NSThread: 0x60000026e100>
{number = 3, name = (null)
}

2018-02-23 20:41:21.037140+0800 YSC-GCD-demo[20008:5024950] 1—<
NSThread: 0x60000026e100>
{number = 3, name = (null)
}

2018-02-23 20:41:23.042220+0800 YSC-GCD-demo[20008:5024950] 2—<
NSThread: 0x60000026e100>
{number = 3, name = (null)
}

2018-02-23 20:41:25.042971+0800 YSC-GCD-demo[20008:5024950] 2—<
NSThread: 0x60000026e100>
{number = 3, name = (null)
}

2018-02-23 20:41:27.047690+0800 YSC-GCD-demo[20008:5024950] 3—<
NSThread: 0x60000026e100>
{number = 3, name = (null)
}

2018-02-23 20:41:29.052327+0800 YSC-GCD-demo[20008:5024950] 3—<
NSThread: 0x60000026e100>
{number = 3, name = (null)
}

在非同步執行 + 序列佇列可以看到：

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

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

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

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

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");

  }複製程式碼

輸出結果：

2018-02-23 20:42:36.842892+0800 YSC-GCD-demo[20041:5030982] currentThread—<
NSThread: 0x600000078a00>
{number = 1, name = main
}

2018-02-23 20:42:36.843050+0800 YSC-GCD-demo[20041:5030982] syncMain—begin

(lldb)

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

• 在主執行緒中使用同步執行 + 主佇列，追加到主執行緒的任務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];
複製程式碼

輸出結果：

2018-02-23 20:44:19.377321+0800 YSC-GCD-demo[20083:5040347] currentThread—<
NSThread: 0x600000272fc0>
{number = 3, name = (null)
}

2018-02-23 20:44:19.377494+0800 YSC-GCD-demo[20083:5040347] syncMain—begin

2018-02-23 20:44:21.384716+0800 YSC-GCD-demo[20083:5040132] 1—<
NSThread: 0x60000006c900>
{number = 1, name = main
}

2018-02-23 20:44:23.386091+0800 YSC-GCD-demo[20083:5040132] 1—<
NSThread: 0x60000006c900>
{number = 1, name = main
}

2018-02-23 20:44:25.387687+0800 YSC-GCD-demo[20083:5040132] 2—<
NSThread: 0x60000006c900>
{number = 1, name = main
}

2018-02-23 20:44:27.388648+0800 YSC-GCD-demo[20083:5040132] 2—<
NSThread: 0x60000006c900>
{number = 1, name = main
}

2018-02-23 20:44:29.390459+0800 YSC-GCD-demo[20083:5040132] 3—<
NSThread: 0x60000006c900>
{number = 1, name = main
}

2018-02-23 20:44:31.391965+0800 YSC-GCD-demo[20083:5040132] 3—<
NSThread: 0x60000006c900>
{number = 1, name = main
}

2018-02-23 20:44:31.392513+0800 YSC-GCD-demo[20083:5040347] syncMain—end

在其他執行緒中使用同步執行 + 主佇列可看到：

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

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

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");

  }複製程式碼

輸出結果：

2018-02-23 20:45:49.981505+0800 YSC-GCD-demo[20111:5046708] currentThread—<
NSThread: 0x60000006d440>
{number = 1, name = main
}

2018-02-23 20:45:49.981935+0800 YSC-GCD-demo[20111:5046708] asyncMain—begin

2018-02-23 20:45:49.982352+0800 YSC-GCD-demo[20111:5046708] asyncMain—end

2018-02-23 20:45:51.991096+0800 YSC-GCD-demo[20111:5046708] 1—<
NSThread: 0x60000006d440>
{number = 1, name = main
}

2018-02-23 20:45:53.991959+0800 YSC-GCD-demo[20111:5046708] 1—<
NSThread: 0x60000006d440>
{number = 1, name = main
}

2018-02-23 20:45:55.992937+0800 YSC-GCD-demo[20111:5046708] 2—<
NSThread: 0x60000006d440>
{number = 1, name = main
}

2018-02-23 20:45:57.993649+0800 YSC-GCD-demo[20111:5046708] 2—<
NSThread: 0x60000006d440>
{number = 1, name = main
}

2018-02-23 20:45:59.994928+0800 YSC-GCD-demo[20111:5046708] 3—<
NSThread: 0x60000006d440>
{number = 1, name = main
}

2018-02-23 20:46:01.995589+0800 YSC-GCD-demo[20111:5046708] 3—<
NSThread: 0x60000006d440>
{number = 1, name = main
}

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

• 所有任務都是在當前執行緒（主執行緒）中執行的，並沒有開啟新的執行緒（雖然非同步執行具備開啟執行緒的能力，但因為是主佇列，所以所有任務都在主執行緒中）。
• 所有任務是在列印的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]);
      // 列印當前執行緒        
  });
    
  });

  }複製程式碼

輸出結果：

2018-02-23 20:47:03.462394+0800 YSC-GCD-demo[20154:5053282] 1—<
NSThread: 0x600000271940>
{number = 3, name = (null)
}

2018-02-23 20:47:05.465912+0800 YSC-GCD-demo[20154:5053282] 1—<
NSThread: 0x600000271940>
{number = 3, name = (null)
}

2018-02-23 20:47:07.466657+0800 YSC-GCD-demo[20154:5052953] 2—<
NSThread: 0x60000007bf80>
{number = 1, name = main
}

• 可以看到在其他執行緒中先執行任務，執行完了之後回到主執行緒執行主執行緒的相應操作。

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)
}

2018-02-23 20:48:26.316956+0800 YSC-GCD-demo[20188:5059274] 3—<
NSThread: 0x600000079d80>
{number = 4, name = (null)
}

2018-02-23 20:48:28.320660+0800 YSC-GCD-demo[20188:5059273] 4—<
NSThread: 0x600000079e00>
{number = 3, name = (null)
}

2018-02-23 20:48:28.320649+0800 YSC-GCD-demo[20188:5059274] 3—<
NSThread: 0x600000079d80>
{number = 4, name = (null)
}

在dispatch_barrier_async相關程式碼執行結果中可以看出：

• 在執行完柵欄前面的操作之後，才執行柵欄操作，最後再執行柵欄後邊的操作。

6.2 GCD 延時執行方法：dispatch_after

我們經常會遇到這樣的需求：在指定時間（例如3秒）之後執行某個任務。可以用 GCD 的dispatch_after函式來實現。需要注意的是：dispatch_after函式並不是在指定時間之後才開始執行處理，而是在指定時間之後將任務追加到主佇列中。嚴格來說，這個時間並不是絕對準確的，但想要大致延遲執行任務，dispatch_after函式是很有效的。

/** * 延時執行方法 dispatch_after */- (void)after { 
   NSLog(@"currentThread---%@",[NSThread currentThread]);
  // 列印當前執行緒    NSLog(@"asyncMain---begin");
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{ 
       // 2.0秒後非同步追加任務程式碼到主佇列，並開始執行        NSLog(@"after---%@",[NSThread currentThread]);
  // 列印當前執行緒    
  });

  }複製程式碼

輸出結果：

2018-02-23 20:53:08.713784+0800 YSC-GCD-demo[20282:5080295] currentThread—<
NSThread: 0x60000006ee00>
{number = 1, name = main
}

2018-02-23 20:53:08.713962+0800 YSC-GCD-demo[20282:5080295] asyncMain—begin

2018-02-23 20:53:10.714283+0800 YSC-GCD-demo[20282:5080295] after—<
NSThread: 0x60000006ee00>
{number = 1, name = main
}

在dispatch_after相關程式碼執行結果中可以看出：在列印 asyncMain---begin 之後大約 2.0 秒的時間，列印了 after---<
NSThread: 0x60000006ee00>
{number = 1, name = main
}

6.3 GCD 一次性程式碼（只執行一次）：dispatch_once

• 我們在建立單例、或者有整個程式執行過程中只執行一次的程式碼時，我們就用到了 GCD 的 dispatch_once 函式。使用dispatch_once 函式能保證某段程式碼在程式執行過程中只被執行1次，並且即使在多執行緒的環境下，dispatch_once也可以保證執行緒安全。

/** * 一次性程式碼（只執行一次）dispatch_once */- (void)once { 
   static dispatch_once_t onceToken;
    dispatch_once(&
onceToken, ^{ 
       // 只執行1次的程式碼(這裡面預設是執行緒安全的)    
  });

  }複製程式碼

6.4 GCD 快速迭代方法：dispatch_apply

• 通常我們會用 for 迴圈遍歷，但是 GCD 給我們提供了快速迭代的函式dispatch_apply。dispatch_apply按照指定的次數將指定的任務追加到指定的佇列中，並等待全部佇列執行結束。

我們可以利用非同步佇列同時遍歷。比如說遍歷 0~5 這6個數字，for 迴圈的做法是每次取出一個元素，逐個遍歷。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");

  }複製程式碼

輸出結果：

2018-02-23 22:03:18.475499+0800 YSC-GCD-demo[20470:5176805] apply—begin

2018-02-23 22:03:18.476672+0800 YSC-GCD-demo[20470:5177035] 1—<
NSThread: 0x60000027b8c0>
{number = 3, name = (null)
}

2018-02-23 22:03:18.476693+0800 YSC-GCD-demo[20470:5176805] 0—<
NSThread: 0x604000070640>
{number = 1, name = main
}

2018-02-23 22:03:18.476704+0800 YSC-GCD-demo[20470:5177037] 2—<
NSThread: 0x604000276800>
{number = 4, name = (null)
}

2018-02-23 22:03:18.476735+0800 YSC-GCD-demo[20470:5177036] 3—<
NSThread: 0x60000027b800>
{number = 5, name = (null)
}

2018-02-23 22:03:18.476867+0800 YSC-GCD-demo[20470:5177035] 4—<
NSThread: 0x60000027b8c0>
{number = 3, name = (null)
}

2018-02-23 22:03:18.476867+0800 YSC-GCD-demo[20470:5176805] 5—<
NSThread: 0x604000070640>
{number = 1, name = main
}

2018-02-23 22:03:18.477038+0800 YSC-GCD-demo[20470:5176805] apply—end

從dispatch_apply相關程式碼執行結果中可以看出：

• 0~5 列印順序不定，最後列印了 apply---end。

因為是在併發佇列中非同步隊執行任務，所以各個任務的執行時間長短不定，最後結束順序也不定。但是apply---end一定在最後執行。這是因為dispatch_apply函式會等待全部任務執行完畢。

6.5 GCD 的佇列組：dispatch_group

有時候我們會有這樣的需求：分別非同步執行2個耗時任務，然後當2個耗時任務都執行完畢後再回到主執行緒執行任務。這時候我們可以用到 GCD 的佇列組。

• 呼叫佇列組的 dispatch_group_async 先把任務放到佇列中，然後將佇列放入佇列組中。或者使用佇列組的 dispatch_group_enter、dispatch_group_leave 組合 來實現dispatch_group_async。
• 呼叫佇列組的 dispatch_group_notify 回到指定執行緒執行任務。或者使用 dispatch_group_wait 回到當前執行緒繼續向下執行（會阻塞當前執行緒）。

6.5.1 dispatch_group_notify

• 監聽 group 中任務的完成狀態，當所有的任務都執行完成後，追加任務到 group 中，並執行任務。

/** * 佇列組 dispatch_group_notify */- (void)groupNotify { 
   NSLog(@"currentThread---%@",[NSThread currentThread]);
  // 列印當前執行緒    NSLog(@"group---begin");
        dispatch_group_t group =  dispatch_group_create();
        dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ 
       // 追加任務1        for (int i = 0;
 i <
 2;
 ++i) { 
           [NSThread sleepForTimeInterval:2];
              // 模擬耗時操作            NSLog(@"1---%@",[NSThread currentThread]);
      // 列印當前執行緒        
  }    
  });
        dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ 
       // 追加任務2        for (int i = 0;
 i <
 2;
 ++i) { 
           [NSThread sleepForTimeInterval:2];
              // 模擬耗時操作            NSLog(@"2---%@",[NSThread currentThread]);
      // 列印當前執行緒        
  }    
  });
        dispatch_group_notify(group, dispatch_get_main_queue(), ^{ 
       // 等前面的非同步任務1、任務2都執行完畢後，回到主執行緒執行下邊任務        for (int i = 0;
 i <
 2;
 ++i) { 
           [NSThread sleepForTimeInterval:2];
              // 模擬耗時操作            NSLog(@"3---%@",[NSThread currentThread]);
      // 列印當前執行緒        
  }        NSLog(@"group---end");
    
  });

  }複製程式碼

輸出結果：

2018-02-23 22:05:03.790035+0800 YSC-GCD-demo[20494:5183349] currentThread—<
NSThread: 0x604000072040>
{number = 1, name = main
}

2018-02-23 22:05:03.790237+0800 YSC-GCD-demo[20494:5183349] group—begin

2018-02-23 22:05:05.792721+0800 YSC-GCD-demo[20494:5183654] 1—<
NSThread: 0x60000026f280>
{number = 4, name = (null)
}

2018-02-23 22:05:05.792725+0800 YSC-GCD-demo[20494:5183656] 2—<
NSThread: 0x60000026f240>
{number = 3, name = (null)
}

2018-02-23 22:05:07.797408+0800 YSC-GCD-demo[20494:5183656] 2—<
NSThread: 0x60000026f240>
{number = 3, name = (null)
}

2018-02-23 22:05:07.797408+0800 YSC-GCD-demo[20494:5183654] 1—<
NSThread: 0x60000026f280>
{number = 4, name = (null)
}

2018-02-23 22:05:09.798717+0800 YSC-GCD-demo[20494:5183349] 3—<
NSThread: 0x604000072040>
{number = 1, name = main
}

2018-02-23 22:05:11.799827+0800 YSC-GCD-demo[20494:5183349] 3—<
NSThread: 0x604000072040>
{number = 1, name = main
}

2018-02-23 22:05:11.799977+0800 YSC-GCD-demo[20494:5183349] group—end

從dispatch_group_notify相關程式碼執行輸出結果可以看出：當所有任務都執行完成之後，才執行dispatch_group_notify block 中的任務。

6.5.2 dispatch_group_wait

• 暫停當前執行緒（阻塞當前執行緒），等待指定的 group 中的任務執行完成後，才會往下繼續執行。

/** * 佇列組 dispatch_group_wait */- (void)groupWait { 
   NSLog(@"currentThread---%@",[NSThread currentThread]);
  // 列印當前執行緒    NSLog(@"group---begin");
        dispatch_group_t group =  dispatch_group_create();
        dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ 
       // 追加任務1        for (int i = 0;
 i <
 2;
 ++i) { 
           [NSThread sleepForTimeInterval:2];
              // 模擬耗時操作            NSLog(@"1---%@",[NSThread currentThread]);
      // 列印當前執行緒        
  }    
  });
        dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ 
       // 追加任務2        for (int i = 0;
 i <
 2;
 ++i) { 
           [NSThread sleepForTimeInterval:2];
              // 模擬耗時操作            NSLog(@"2---%@",[NSThread currentThread]);
      // 列印當前執行緒        
  }    
  });
        // 等待上面的任務全部完成後，會往下繼續執行（會阻塞當前執行緒）    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
        NSLog(@"group---end");

  }複製程式碼

輸出結果：

2018-02-23 22:10:16.939258+0800 YSC-GCD-demo[20538:5198871] currentThread—<
NSThread: 0x600000066780>
{number = 1, name = main
}

2018-02-23 22:10:16.939455+0800 YSC-GCD-demo[20538:5198871] group—begin

2018-02-23 22:10:18.943862+0800 YSC-GCD-demo[20538:5199137] 2—<
NSThread: 0x600000464b80>
{number = 4, name = (null)
}

2018-02-23 22:10:18.943861+0800 YSC-GCD-demo[20538:5199138] 1—<
NSThread: 0x604000076640>
{number = 3, name = (null)
}

2018-02-23 22:10:20.947787+0800 YSC-GCD-demo[20538:5199137] 2—<
NSThread: 0x600000464b80>
{number = 4, name = (null)
}

2018-02-23 22:10:20.947790+0800 YSC-GCD-demo[20538:5199138] 1—<
NSThread: 0x604000076640>
{number = 3, name = (null)
}

2018-02-23 22:10:20.948134+0800 YSC-GCD-demo[20538:5198871] group—end

從dispatch_group_wait相關程式碼執行輸出結果可以看出：當所有任務執行完成之後，才執行 dispatch_group_wait 之後的操作。但是，使用dispatch_group_wait 會阻塞當前執行緒。

6.5.3 dispatch_group_enter、dispatch_group_leave

• dispatch_group_enter 標誌著一個任務追加到 group，執行一次，相當於 group 中未執行完畢任務數+1
• dispatch_group_leave 標誌著一個任務離開了 group，執行一次，相當於 group 中未執行完畢任務數-1。
• 當 group 中未執行完畢任務數為0的時候，才會使dispatch_group_wait解除阻塞，以及執行追加到dispatch_group_notify中的任務。

/** * 佇列組 dispatch_group_enter、dispatch_group_leave */- (void)groupEnterAndLeave{ 
   NSLog(@"currentThread---%@",[NSThread currentThread]);
  // 列印當前執行緒    NSLog(@"group---begin");
        dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_enter(group);
    dispatch_async(queue, ^{ 
       // 追加任務1        for (int i = 0;
 i <
 2;
 ++i) { 
           [NSThread sleepForTimeInterval:2];
              // 模擬耗時操作            NSLog(@"1---%@",[NSThread currentThread]);
      // 列印當前執行緒        
  }        dispatch_group_leave(group);
    
  });
        dispatch_group_enter(group);
    dispatch_async(queue, ^{ 
       // 追加任務2        for (int i = 0;
 i <
 2;
 ++i) { 
           [NSThread sleepForTimeInterval:2];
              // 模擬耗時操作            NSLog(@"2---%@",[NSThread currentThread]);
      // 列印當前執行緒        
  }        dispatch_group_leave(group);
    
  });
        dispatch_group_notify(group, dispatch_get_main_queue(), ^{ 
       // 等前面的非同步操作都執行完畢後，回到主執行緒.        for (int i = 0;
 i <
 2;
 ++i) { 
           [NSThread sleepForTimeInterval:2];
              // 模擬耗時操作            NSLog(@"3---%@",[NSThread currentThread]);
      // 列印當前執行緒        
  }        NSLog(@"group---end");
    
  });
    //    // 等待上面的任務全部完成後，會往下繼續執行（會阻塞當前執行緒）//    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
////    NSLog(@"group---end");

  }複製程式碼

輸出結果：

2018-02-23 22:14:17.997667+0800 YSC-GCD-demo[20592:5214830] currentThread—<
NSThread: 0x604000066600>
{number = 1, name = main
}

2018-02-23 22:14:17.997839+0800 YSC-GCD-demo[20592:5214830] group—begin

2018-02-23 22:14:20.000298+0800 YSC-GCD-demo[20592:5215094] 1—<
NSThread: 0x600000277c80>
{number = 4, name = (null)
}

2018-02-23 22:14:20.000305+0800 YSC-GCD-demo[20592:5215095] 2—<
NSThread: 0x600000277c40>
{number = 3, name = (null)
}

2018-02-23 22:14:22.001323+0800 YSC-GCD-demo[20592:5215094] 1—<
NSThread: 0x600000277c80>
{number = 4, name = (null)
}

2018-02-23 22:14:22.001339+0800 YSC-GCD-demo[20592:5215095] 2—<
NSThread: 0x600000277c40>
{number = 3, name = (null)
}

2018-02-23 22:14:24.002321+0800 YSC-GCD-demo[20592:5214830] 3—<
NSThread: 0x604000066600>
{number = 1, name = main
}

2018-02-23 22:14:26.002852+0800 YSC-GCD-demo[20592:5214830] 3—<
NSThread: 0x604000066600>
{number = 1, name = main
}

2018-02-23 22:14:26.003116+0800 YSC-GCD-demo[20592:5214830] group—end

從dispatch_group_enter、dispatch_group_leave相關程式碼執行結果中可以看出：當所有任務執行完成之後，才執行 dispatch_group_notify 中的任務。這裡的dispatch_group_enter、dispatch_group_leave組合，其實等同於dispatch_group_async。

6.6 GCD 訊號量：dispatch_semaphore

GCD 中的訊號量是指 Dispatch Semaphore，是持有計數的訊號。類似於過高速路收費站的欄杆。可以通過時，開啟欄杆，不可以通過時，關閉欄杆。在 Dispatch Semaphore 中，使用計數來完成這個功能，計數為0時等待，不可通過。計數為1或大於1時，計數減1且不等待，可通過。Dispatch Semaphore 提供了三個函式。

• dispatch_semaphore_create：建立一個Semaphore並初始化訊號的總量
• dispatch_semaphore_signal：傳送一個訊號，讓訊號總量加1
• dispatch_semaphore_wait：可以使總訊號量減1，當訊號總量為0時就會一直等待（阻塞所線上程），否則就可以正常執行。

注意：訊號量的使用前提是：想清楚你需要處理哪個執行緒等待（阻塞），又要哪個執行緒繼續執行，然後使用訊號量。

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

• 保持執行緒同步，將非同步執行任務轉換為同步執行任務
• 保證執行緒安全，為執行緒加鎖

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 實現執行緒同步，將非同步執行任務轉換為同步執行任務。

/** * semaphore 執行緒同步 */- (void)semaphoreSync { 
       NSLog(@"currentThread---%@",[NSThread currentThread]);
  // 列印當前執行緒    NSLog(@"semaphore---begin");
        dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
        __block int number = 0;
    dispatch_async(queue, ^{ 
       // 追加任務1        [NSThread sleepForTimeInterval:2];
              // 模擬耗時操作        NSLog(@"1---%@",[NSThread currentThread]);
      // 列印當前執行緒                number = 100;
                dispatch_semaphore_signal(semaphore);
    
  });
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    NSLog(@"semaphore---end,number = %zd",number);

  }複製程式碼

輸出結果：

2018-02-23 22:22:26.521665+0800 YSC-GCD-demo[20642:5246341] currentThread—<
NSThread: 0x60400006bc80>
{number = 1, name = main
}

2018-02-23 22:22:26.521869+0800 YSC-GCD-demo[20642:5246341] semaphore—begin

2018-02-23 22:22:28.526841+0800 YSC-GCD-demo[20642:5246638] 1—<
NSThread: 0x600000272300>
{number = 3, name = (null)
}

2018-02-23 22:22:28.527030+0800 YSC-GCD-demo[20642:5246341] semaphore—end,number = 100

從 Dispatch Semaphore 實現執行緒同步的程式碼可以看到：

• semaphore---end 是在執行完 number = 100;
之後才列印的。而且輸出結果 number 為 100。這是因為非同步執行不會做任何等待，可以繼續執行任務。非同步執行將任務1追加到佇列之後，不做等待，接著執行dispatch_semaphore_wait方法。此時 semaphore == 0，當前執行緒進入等待狀態。然後，非同步任務1開始執行。任務1執行到dispatch_semaphore_signal之後，總訊號量，此時 semaphore == 1，dispatch_semaphore_wait方法使總訊號量減1，正在被阻塞的執行緒（主執行緒）恢復繼續執行。最後列印semaphore---end,number = 100。這樣就實現了執行緒同步，將非同步執行任務轉換為同步執行任務。

6.6.2 Dispatch Semaphore 執行緒安全和執行緒同步（為執行緒加鎖）

執行緒安全：如果你的程式碼所在的程式中有多個執行緒在同時執行，而這些執行緒可能會同時執行這段程式碼。如果每次執行結果和單執行緒執行的結果是一樣的，而且其他的變數的值也和預期的是一樣的，就是執行緒安全的。

若每個執行緒中對全域性變數、靜態變數只有讀操作，而無寫操作，一般來說，這個全域性變數是執行緒安全的；若有多個執行緒同時執行寫操作（更改變數），一般都需要考慮執行緒同步，否則的話就可能影響執行緒安全。

執行緒同步：可理解為執行緒 A 和 執行緒 B 一塊配合，A 執行到一定程度時要依靠執行緒 B 的某個結果，於是停下來，示意 B 執行；B 依言執行，再將結果給 A；A 再繼續操作。

舉個簡單例子就是：兩個人在一起聊天。兩個人不能同時說話，避免聽不清(操作衝突)。等一個人說完(一個執行緒結束操作)，另一個再說(另一個執行緒再開始操作)。

下面，我們模擬火車票售賣的方式，實現 NSThread 執行緒安全和解決執行緒同步問題。

場景：總共有50張火車票，有兩個售賣火車票的視窗，一個是北京火車票售賣視窗，另一個是上海火車票售賣視窗。兩個視窗同時售賣火車票，賣完為止。

6.6.2.1 非執行緒安全（不使用 semaphore）

先來看看不考慮執行緒安全的程式碼：

/** * 非執行緒安全：不使用 semaphore * 初始化火車票數量、賣票視窗(非執行緒安全)、並開始賣票 */- (void)initTicketStatusNotSave { 
   NSLog(@"currentThread---%@",[NSThread currentThread]);
  // 列印當前執行緒    NSLog(@"semaphore---begin");
        self.ticketSurplusCount = 50;
        // queue1 代表北京火車票售賣視窗    dispatch_queue_t queue1 = dispatch_queue_create("net.bujige.testQueue1", DISPATCH_QUEUE_SERIAL);
    // queue2 代表上海火車票售賣視窗    dispatch_queue_t queue2 = dispatch_queue_create("net.bujige.testQueue2", DISPATCH_QUEUE_SERIAL);
        __weak typeof(self) weakSelf = self;
    dispatch_async(queue1, ^{ 
       [weakSelf saleTicketNotSafe];
    
  });
        dispatch_async(queue2, ^{ 
       [weakSelf saleTicketNotSafe];
    
  });

  }/** * 售賣火車票(非執行緒安全) */- (void)saleTicketNotSafe { 
   while (1) { 
               if (self.ticketSurplusCount >
 0) { 
 //如果還有票，繼續售賣            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩餘票數：%d 視窗：%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        
  } else { 
//如果已賣完，關閉售票視窗            NSLog(@"所有火車票均已售完");
            break;
        
  }            
  }
  }複製程式碼

輸出結果（部分）：

2018-02-23 22:25:35.789072+0800 YSC-GCD-demo[20712:5258914] currentThread—<
NSThread: 0x604000068880>
{number = 1, name = main
}

2018-02-23 22:25:35.789260+0800 YSC-GCD-demo[20712:5258914] semaphore—begin

2018-02-23 22:25:35.789641+0800 YSC-GCD-demo[20712:5259176] 剩餘票數：48 視窗：<
NSThread: 0x60000027db80>
{number = 3, name = (null)
}

2018-02-23 22:25:35.789646+0800 YSC-GCD-demo[20712:5259175] 剩餘票數：49 視窗：<
NSThread: 0x60000027e740>
{number = 4, name = (null)
}

2018-02-23 22:25:35.994113+0800 YSC-GCD-demo[20712:5259175] 剩餘票數：47 視窗：<
NSThread: 0x60000027e740>
{number = 4, name = (null)
}

2018-02-23 22:25:35.994129+0800 YSC-GCD-demo[20712:5259176] 剩餘票數：46 視窗：<
NSThread: 0x60000027db80>
{number = 3, name = (null)
}

2018-02-23 22:25:36.198993+0800 YSC-GCD-demo[20712:5259176] 剩餘票數：45 視窗：<
NSThread: 0x60000027db80>
{number = 3, name = (null)
}

……

可以看到在不考慮執行緒安全，不使用 semaphore 的情況下，得到票數是錯亂的，這樣顯然不符合我們的需求，所以我們需要考慮執行緒安全問題。

6.6.2.2 執行緒安全（使用 semaphore 加鎖）

考慮執行緒安全的程式碼：

/** * 執行緒安全：使用 semaphore 加鎖 * 初始化火車票數量、賣票視窗(執行緒安全)、並開始賣票 */- (void)initTicketStatusSave { 
   NSLog(@"currentThread---%@",[NSThread currentThread]);
  // 列印當前執行緒    NSLog(@"semaphore---begin");
        semaphoreLock = dispatch_semaphore_create(1);
        self.ticketSurplusCount = 50;
        // queue1 代表北京火車票售賣視窗    dispatch_queue_t queue1 = dispatch_queue_create("net.bujige.testQueue1", DISPATCH_QUEUE_SERIAL);
    // queue2 代表上海火車票售賣視窗    dispatch_queue_t queue2 = dispatch_queue_create("net.bujige.testQueue2", DISPATCH_QUEUE_SERIAL);
        __weak typeof(self) weakSelf = self;
    dispatch_async(queue1, ^{ 
       [weakSelf saleTicketSafe];
    
  });
        dispatch_async(queue2, ^{ 
       [weakSelf saleTicketSafe];
    
  });

  }/** * 售賣火車票(執行緒安全) */- (void)saleTicketSafe { 
   while (1) { 
       // 相當於加鎖        dispatch_semaphore_wait(semaphoreLock, DISPATCH_TIME_FOREVER);
                if (self.ticketSurplusCount >
 0) { 
 //如果還有票，繼續售賣            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩餘票數：%d 視窗：%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        
  } else { 
//如果已賣完，關閉售票視窗            NSLog(@"所有火車票均已售完");
                        // 相當於解鎖            dispatch_semaphore_signal(semaphoreLock);
            break;
        
  }                // 相當於解鎖        dispatch_semaphore_signal(semaphoreLock);
    
  }
  }複製程式碼

輸出結果為：

2018-02-23 22:32:19.814232+0800 YSC-GCD-demo[20862:5290531] currentThread—<
NSThread: 0x6000000783c0>
{number = 1, name = main
}

2018-02-23 22:32:19.814412+0800 YSC-GCD-demo[20862:5290531] semaphore—begin

2018-02-23 22:32:19.814837+0800 YSC-GCD-demo[20862:5290687] 剩餘票數：49 視窗：<
NSThread: 0x6040002709c0>
{number = 3, name = (null)
}

2018-02-23 22:32:20.017745+0800 YSC-GCD-demo[20862:5290689] 剩餘票數：48 視窗：<
NSThread: 0x60000046c640>
{number = 4, name = (null)
}

2018-02-23 22:32:20.222039+0800 YSC-GCD-demo[20862:5290687] 剩餘票數：47 視窗：<
NSThread: 0x6040002709c0>
{number = 3, name = (null)
}

……

2018-02-23 22:32:29.024817+0800 YSC-GCD-demo[20862:5290689] 剩餘票數：4 視窗：<
NSThread: 0x60000046c640>
{number = 4, name = (null)
}

2018-02-23 22:32:29.230110+0800 YSC-GCD-demo[20862:5290687] 剩餘票數：3 視窗：<
NSThread: 0x6040002709c0>
{number = 3, name = (null)
}

2018-02-23 22:32:29.433615+0800 YSC-GCD-demo[20862:5290689] 剩餘票數：2 視窗：<
NSThread: 0x60000046c640>
{number = 4, name = (null)
}

2018-02-23 22:32:29.637572+0800 YSC-GCD-demo[20862:5290687] 剩餘票數：1 視窗：<
NSThread: 0x6040002709c0>
{number = 3, name = (null)
}

2018-02-23 22:32:29.840234+0800 YSC-GCD-demo[20862:5290689] 剩餘票數：0 視窗：<
NSThread: 0x60000046c640>
{number = 4, name = (null)
}

2018-02-23 22:32:30.044960+0800 YSC-GCD-demo[20862:5290687] 所有火車票均已售完

2018-02-23 22:32:30.045260+0800 YSC-GCD-demo[20862:5290689] 所有火車票均已售完

可以看出，在考慮了執行緒安全的情況下，使用 dispatch_semaphore機制之後，得到的票數是正確的，沒有出現混亂的情況。我們也就解決了多個執行緒同步的問題。

---

參考資料：

• iOS GCD之dispatch_semaphore（訊號量）
• Objective-C 高階程式設計 iOS 與 OS X 多執行緒和記憶體管理

---

iOS多執行緒詳盡總結系列文章：

• iOS多執行緒：『pthread、NSThread』詳盡總結
• iOS多執行緒：『GCD』詳盡總結
• iOS多執行緒：『NSOperation、NSOperationQueue』詳盡總結

待完成：

• iOS多執行緒：『RunLoop』詳盡總結

來源：https://juejin.im/post/5a90de68f265da4e9b592b40