一、GCD簡介

Grand Central Dispatch（GCD）是 Apple 開發的一個多核編程的較新的解決方法。它主要用於優化應用程序以支持多核處理器以及其他對稱多處理系統。它是一個在線程池模式的基礎上執行的併發任務。在 Mac OS X 10.6 雪豹中首次推出，也可在 iOS 4 及以上版本使用。GCD 有很多好處啊，具體如下：

GCD 會自動利用更多的 CPU 內核（比如雙核、四核）；
GCD 會自動管理線程的生命週期（創建線程、調度任務、銷燬線程）；
使用簡單（只需提供回調即可）

二、GCD 任務和隊列

學習 GCD 之前，先來了解 GCD 中兩個核心概念：『任務』和『隊列』。
任務：就是執行操作的意思，換句話說就是你的線程中執行的那段代碼。在 GCD 中是放在 block 中的。執行任務有兩種方式：『同步執行』和『異步執行』。兩者的主要區別是：是否等待隊列的任務執行結束，以及是否具備開啓新線程的能力。

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

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

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

在 GCD 中有兩種隊列：『串行隊列』和『併發隊列』。兩者都符合 FIFO（先進先出）的原則。兩者的主要區別是：執行順序不同，以及開啓線程數不同。
串行隊列（Serial Dispatch Queue）：每次只有一個任務被執行。讓任務一個接着一個地執行。（只開啓一個線程，一個任務執行完畢後，再執行下一個任務）
併發隊列（Concurrent Dispatch Queue）：可以讓多個任務併發（同時）執行。（可以開啓多個線程，並且同時執行任務）

三、使用GCD

GCD 的使用步驟其實很簡單，只有兩步：創建一個隊列（串行隊列或併發隊列）；將任務追加到任務的等待隊列中，然後系統就會根據任務類型執行任務（同步執行或異步執行）。

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

可以使用 dispatch_queue_create 方法來創建隊列。該方法需要傳入兩個參數：

第一個參數表示隊列的唯一標識符，用於 DEBUG，可爲空。隊列的名稱推薦使用應用程序 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, ^{
    // 這裏放異步執行任務代碼
});

3.3 任務+執行

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

同步執行 + 併發隊列
異步執行 + 併發隊列
同步執行 + 串行隊列
異步執行 + 串行隊列
實際上，剛纔還說了兩種默認隊列：全局併發隊列、主隊列。全局併發隊列可以作爲普通併發隊列來使用。但是當前代碼默認放在主隊列中，所以主隊列很有必要專門來研究一下，所以我們就又多了兩種組合方式。這樣就有六種不同的組合方式了。
同步執行 + 主隊列
異步執行 + 主隊列
那麼這幾種不同組合方式各有什麼區別呢？

區別	併發隊列	串行隊列	主隊列
同步（sync）	沒有開啓新線程，串行執行任務	沒有開啓新線程，串行執行任務	死鎖卡住不執行
異步（async）	有開啓新線程，併發執行任務	有開啓新線程（1條），串行執行任務	沒有開啓新線程，串行執行任務

注意：從上邊可看出：『主線程』中調用『主隊列』+『同步執行』會導致死鎖問題。
這是因爲主隊列中追加的同步任務和主線程本身的任務兩者之間相互等待，阻塞了『主隊列』，最終造成了主隊列所在的線程（主線程）死鎖問題。
而如果我們在『其他線程』調用『主隊列』+『同步執行』，則不會阻塞『主隊列』，自然也不會造成死鎖問題。最終的結果是：不會開啓新線程，串行執行任務。

3.4 隊列嵌套情況下，不同組合方式區別

除了上邊提到的『主線程』中調用『主隊列』+『同步執行』會導致死鎖問題。實際在使用『串行隊列』的時候，也可能出現阻塞『串行隊列』所在線程的情況發生，從而造成死鎖問題。這種情況多見於同一個串行隊列的嵌套使用。
比如下面代碼這樣：在『異步執行』+『串行隊列』的任務中，又嵌套了『當前的串行隊列』，然後進行『同步執行』。

dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{    // 異步執行 + 串行隊列
    dispatch_sync(queue, ^{  // 同步執行 + 當前串行隊列
        // 追加任務 1
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當前線程
    });
});

執行上面的代碼會導致串行隊列中追加的任務和串行隊列中原有的任務兩者之間相互等待，阻塞了『串行隊列』，最終造成了串行隊列所在的線程（子線程）死鎖問題。主隊列造成死鎖也是基於這個原因，所以，這也進一步說明了主隊列其實並不特殊。關於『隊列中嵌套隊列』這種複雜情況，這裏也簡單做一個總結。不過這裏只考慮同一個隊列的嵌套情況，關於多個隊列的相互嵌套情況還請自行研究，或者等我最新的文章發佈。
『不同隊列』+『不同任務』組合，以及『隊列中嵌套隊列』使用的區別：

區別	『異步執行+併發隊列』嵌套『同一個併發隊列』	『同步執行+併發隊列』嵌套『同一個併發隊列』	『異步執行+串行隊列』嵌套『同一個串行隊列』	『同步執行+串行隊列』嵌套『同一個串行隊列』
同步（sync）	沒有開啓新的線程，串行執行任務	沒有開啓新線程，串行執行任務	死鎖卡住不執行死鎖卡住不執行	死鎖卡住不執行死鎖卡住不執行
異步（async）	有開啓新線程，併發執行任務	有開啓新線程，併發執行任務	有開啓新線程（1 條），串行執行任務	有開啓新線程（1 條），串行執行任務

好了，關於『不同隊列』+『不同任務』組合不同區別總結就到這裏。

3.5 關於不同隊列和不同任務的形象理解

因爲前一段時間看到了有朋友留言說對異步執行和併發隊列中創建線程能力有所不理解，我覺得這個問題的確很容易造成困惑，所以很值得拿來專門分析一下。
他的問題：

在異步 + 併發中的解釋：
（異步執行具備開啓新線程的能力。且併發隊列可開啓多個線程，同時執行多個任務）
以及同步 + 併發中的解釋：
（雖然併發隊列可以開啓多個線程，並且同時執行多個任務。但是因爲本身不能創建新線程，只有當前線程這一個線程（同步任務不具備開啓新線程的能力）
        這個地方看起來有點疑惑，你兩個地方分別提到：異步執行開啓新線程，併發隊列也可以開啓新線程，想請教下，你的意思是隻有任務才擁有創建新線程的能力，而隊列只有開啓線程的能力，並不能創建線程？這二者是這樣的關聯嗎？
        關於這個問題，我想做一個很形象的類比，來幫助大家對隊列、任務以及線程之間關係的理解。
        假設現在有 5 個人要穿過一道門禁，這道門禁總共有 10 個入口，管理員可以決定同一時間打開幾個入口，可以決定同一時間讓一個人單獨通過還是多個人一起通過。不過默認情況下，管理員只開啓一個入口，且一個通道一次只能通過一個人。
        這個故事裏，人好比是任務，管理員好比是系統，入口則代表線程。

5 個人表示有 5 個任務，10 個入口代表 10 條線程。
串行隊列好比是 5 個人排成一支長隊。
併發隊列好比是 5 個人排成多支隊伍，比如 2 隊，或者 3 隊。
同步任務好比是管理員只開啓了一個入口（當前線程）。
異步任務好比是管理員同時開啓了多個入口（當前線程 + 新開的線程）。
『異步執行 + 併發隊列』可以理解爲：現在管理員開啓了多個入口（比如 3 個入口），5 個人排成了多支隊伍（比如 3 支隊伍），這樣這 5 個人就可以 3 個人同時一起穿過門禁了。
『同步執行 + 併發隊列』可以理解爲：現在管理員只開啓了 1 個入口，5 個人排成了多支隊伍。雖然這 5 個人排成了多支隊伍，但是隻開了 1 個入口啊，這 5 個人雖然都想快點過去，但是 1 個入口一次只能過 1 個人，所以大家就只好一個接一個走過去了，表現的結果就是：順次通過入口。
換成 GCD 裏的語言就是說：
『異步執行 + 併發隊列』就是：系統開啓了多個線程（主線程+其他子線程），任務可以多個同時運行。
『同步執行 + 併發隊列』就是：系統只默認開啓了一個主線程，沒有開啓子線程，雖然任務處於併發隊列中，但也只能一個接一個執行了。
下邊我們來研究一下上邊提到的六種簡單組合方式的使用方法。

四、GCD 的其他方法

4.1 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
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當前線程
    });
    dispatch_async(queue, ^{
        // 追加任務 2
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    dispatch_barrier_async(queue, ^{
        // 追加任務 barrier
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"barrier---%@",[NSThread currentThread]);// 打印當前線程
    });
    
    dispatch_async(queue, ^{
        // 追加任務 3
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印當前線程
    });
    dispatch_async(queue, ^{
        // 追加任務 4
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"4---%@",[NSThread currentThread]);      // 打印當前線程
    });
}

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

4.3 CD 一次性代碼（只執行一次）：dispatch_once

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

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

4.4 GCD 快速迭代方法：dispatch_apply

        通常我們會用 for 循環遍歷，但是 GCD 給我們提供了快速迭代的方法 dispatch_apply。dispatch_apply 按照指定的次數將指定的任務追加到指定的隊列中，並等待全部隊列執行結束。
        如果是在串行隊列中使用 dispatch_apply，那麼就和 for 循環一樣，按順序同步執行。但是這樣就體現不出快速迭代的意義了。
        我們可以利用併發隊列進行異步執行。比如說遍歷 0~5 這 6 個數字，for 循環的做法是每次取出一個元素，逐個遍歷。dispatch_apply 可以在多個線程中同時（異步）遍歷多個數字。
        還有一點，無論是在串行隊列，還是併發隊列中，dispatch_apply 都會等待全部任務執行完畢，這點就像是同步操作，也像是隊列組中的 dispatch_group_wait方法。

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

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

4.5 GCD 隊列組：dispatch_group

4.5.1 dispatch_group_notify

/**
 * 隊列組 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
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任務 2
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的異步任務 1、任務 2 都執行完畢後，回到主線程執行下邊任務
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印當前線程

        NSLog(@"group---end");
    });
}

2019-08-08 15:07:21.601734+0800 YSC-GCD-demo[17813:4293874] currentThread—-{number = 1, name = main}
2019-08-08 15:07:21.601871+0800 YSC-GCD-demo[17813:4293874] group—-begin
2019-08-08 15:07:23.604854+0800 YSC-GCD-demo[17813:4294048] 2—-{number = 4, name = (null)}
2019-08-08 15:07:23.604852+0800 YSC-GCD-demo[17813:4294053] 1—-{number = 3, name = (null)}
2019-08-08 15:07:25.606067+0800 YSC-GCD-demo[17813:4293874] 3—-{number = 1, name = main}
2019-08-08 15:07:25.606255+0800 YSC-GCD-demo[17813:4293874] group—-end

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

4.5.2 dispatch_group_wait

// 暫停當前線程（阻塞當前線程），等待指定的 group 中的任務執行完成後，纔會往下繼續執行。
- (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
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任務 2
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印當前線程
    });
    
    // 等待上面的任務全部完成後，會往下繼續執行（會阻塞當前線程）
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    
    NSLog(@"group---end");
    
}

2019-08-08 15:09:12.441729+0800 YSC-GCD-demo[17844:4299926] currentThread—-{number = 1, name = main}
2019-08-08 15:09:12.441870+0800 YSC-GCD-demo[17844:4299926] group—-begin
2019-08-08 15:09:14.445790+0800 YSC-GCD-demo[17844:4300046] 2—-{number = 4, name = (null)}
2019-08-08 15:09:14.445760+0800 YSC-GCD-demo[17844:4300043] 1—-{number = 3, name = (null)}
2019-08-08 15:09:14.446039+0800 YSC-GCD-demo[17844:4299926] group—-end

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

4.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
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印當前線程

        dispatch_group_leave(group);
    });
    
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        // 追加任務 2
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印當前線程
        
        dispatch_group_leave(group);
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的異步操作都執行完畢後，回到主線程.
        [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印當前線程
    
        NSLog(@"group---end");
    });
}


2019-08-08 15:13:17.983283+0800 YSC-GCD-demo[17924:4314716] currentThread—-{number = 1, name = main}
2019-08-08 15:13:17.983429+0800 YSC-GCD-demo[17924:4314716] group—-begin
2019-08-08 15:13:19.988898+0800 YSC-GCD-demo[17924:4314816] 2—-{number = 3, name = (null)}
2019-08-08 15:13:19.988888+0800 YSC-GCD-demo[17924:4314808] 1—-{number = 4, name = (null)}
2019-08-08 15:13:21.990450+0800 YSC-GCD-demo[17924:4314716] 3—-{number = 1, name = main}
2019-08-08 15:13:21.990711+0800 YSC-GCD-demo[17924:4314716] group—-end

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

6.6 信號量：dispatch_semaphore

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

dispatch_semaphore_create：創建一個 Semaphore 並初始化信號的總量
dispatch_semaphore_signal：發送一個信號，讓信號總量加 1
dispatch_semaphore_wait：可以使總信號量減 1，信號總量小於 0 時就會一直等待（阻塞所在線程），否則就可以正常執行。

注意：信號量的使用前提是：想清楚你需要處理哪個線程等待（阻塞），又要哪個線程繼續執行，然後使用信號量。
Dispatch Semaphore 在實際開發中主要用於：

保持線程同步，將異步執行任務轉換爲同步執行任務
保證線程安全，爲線程加鎖

// 總共有 50 張火車票，有兩個售賣火車票的窗口，一個是北京火車票售賣窗口，另一個是上海火車票售賣窗口。兩個窗口同時售賣火車票，賣完爲止。

/**
 * 線程安全：使用 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);
    }
}

備註
1、非本人原創，爲了學習閱讀並加入了部分修改，原文鏈接：[https://bujige.net/blog/iOS-Complete-learning-GCD.html)
2、感謝作者！

iOS多線程——GCD 一、GCD簡介二、GCD 任務和隊列三、使用GCD 四、GCD 的其他方法

一、GCD簡介

二、GCD 任務和隊列

三、使用GCD

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

3.2 任務的創建方法

3.3 任務+執行

3.4 隊列嵌套情況下，不同組合方式區別

3.5 關於不同隊列和不同任務的形象理解

四、GCD 的其他方法

4.1 dispatch_barrier_async

4.2 GCD 延時執行方法：dispatch_after

4.3 CD 一次性代碼（只執行一次）：dispatch_once

4.4 GCD 快速迭代方法：dispatch_apply

4.5 GCD 隊列組：dispatch_group

4.5.1 dispatch_group_notify

4.5.2 dispatch_group_wait

4.5.3 dispatch_group_enter、dispatch_group_leave

6.6 信號量：dispatch_semaphore

2024年DataOps趨勢預測：AI不會取代數據工程師

雲原生週刊：K8s 中的服務和網絡｜ 2024.4.29

[轉帖]cpupower

今天，昨天，近七天，近30天，近90天，js封裝

華爲云云原生FinOps解決方案，釋放雲原生最大價值

LLDB全方位剖析

LLDB詳解一、引言二、LLDB命令三、使用LLDB 四、擴展LLDB 四、參考資料

預處理(宏)——想說愛你不容易一、工作中遇到的怪事二、問題詳解三、最佳實現

詳解KVO 一、基本概念二、基本用法三、高級用法四、關於NSKVONotifying_原類型名（簡稱此類爲中間類）

SwiftUI基礎教程（3）第二章：SwiftUI基礎元素實例

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

iOS多線程——GCD 一、GCD簡介 二、GCD 任務和隊列 三、使用GCD 四、GCD 的其他方法

一、GCD簡介

二、GCD 任務和隊列

三、使用GCD

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

3.2 任務的創建方法

3.3 任務+執行

3.4 隊列嵌套情況下，不同組合方式區別

3.5 關於不同隊列和不同任務的形象理解

四、GCD 的其他方法

4.1 dispatch_barrier_async

4.2 GCD 延時執行方法：dispatch_after

4.3 CD 一次性代碼（只執行一次）：dispatch_once

4.4 GCD 快速迭代方法：dispatch_apply

4.5 GCD 隊列組：dispatch_group

4.5.1 dispatch_group_notify

4.5.2 dispatch_group_wait

4.5.3 dispatch_group_enter、dispatch_group_leave

6.6 信號量：dispatch_semaphore

iOS多線程——GCD 一、GCD簡介二、GCD 任務和隊列三、使用GCD 四、GCD 的其他方法