iOS GCD詳解

本文是由於筆者在閱讀有關多執行緒的文章的時候,看到的覺得寫的很好, 就此記錄下.

在開發 APP 的時候很多時候可能會用到多執行緒, 就個人而言我是比較喜歡使用 GCD 的
那麼使用 GCD 有什麼好處呢?
1.GCD 可用於多核的並行運算
2.GCD 會自動利用更多的 CPU 核心（比如雙核、四核）
3.GCD 會自動管理執行緒的生命週期（建立執行緒、排程任務、銷燬執行緒）
4.程式設計師只需要告訴 GCD 想要執行什麼任務，不需要編寫任何執行緒管理程式碼

1.GCD的任務和佇列

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

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

同步執行（sync）：
同步新增任務到指定的佇列中，在新增的任務執行結束之前，會一直等待，直到佇列裡面的任務完成之後再繼續執行。
只能在當前執行緒中執行任務，特點是:不具備開啟新執行緒的能力。

非同步執行（async）：
非同步新增任務到指定的佇列中，它不會做任何等待，可以繼續執行任務。
可以在新的執行緒中執行任務，特點是:具備開啟新執行緒的能力。

注意：非同步執行（async）雖然具有開啟新執行緒的能力，但是並不一定開啟新執行緒。這跟任務所指定的佇列型別有關（下面會講）。

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

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

序列佇列（Serial Dispatch Queue）：

每次只有一個任務被執行。讓任務一個接著一個地執行。（只開啟一個執行緒，一個任務執行完畢後，再執行下一個任務）

併發佇列（Concurrent Dispatch Queue）：

可以讓多個任務併發（同時）執行。（可以開啟多個執行緒，並且同時執行任務）

注意：併發佇列的併發功能只有在非同步（dispatch_async）函式下才有效

2 GCD 的使用步驟

1.建立一個佇列（序列佇列或併發佇列）

2將任務追加到任務的等待佇列中，然後系統就會根據任務型別執行任務（同步執行或非同步執行）

2.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);

建立任務

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

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

雖然使用 GCD 只需要兩步,但是我們知道有兩種佇列(序列佇列/併發佇列) 還有兩種執行方法(同步執行/非同步執行)所以就有4中情況

1.同步執行 + 併發佇列
2.非同步執行 + 併發佇列
3.同步執行 + 序列佇列
4.非同步執行 + 序列佇列

上面也還提到了還存在一種主佇列那麼還有下面兩種

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

那麼他們的區別呢

60FF3328-8BB8-4E26-9720-F8DE0736015C.png

3.GCD 的基本使用

3.1 同步執行 + 併發佇列

特點是: 在當前執行緒中執行任務，不會開啟新執行緒，執行完一個任務，再執行下一個任務。

/*
 同步執行 + 併發佇列
 特點: 在當前執行緒中執行任務，不會開啟新執行緒，執行完一個任務，再執行下一個任務。
 */
-(void)syncConcurrent{
    DLog(@"currentThread----%@",[NSThread currentThread]);              //列印當前執行緒
    DLog(@"syncConcurrent-------begin");
    dispatch_queue_t queue = dispatch_queue_create("com.wangyu.cn.YukiFramework", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_sync(queue, ^{
        // 任務1
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];                          // 模擬耗時操作
            DLog(@"1----%@",[NSThread currentThread]);                  //列印當前執行緒
        }
    });
    
    dispatch_sync(queue, ^{
        // 任務2
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];                          // 模擬耗時操作
            DLog(@"2----%@",[NSThread currentThread]);                  //列印當前執行緒
        }
    });
    
    dispatch_sync(queue, ^{
        // 任務3
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];                          // 模擬耗時操作
            DLog(@"3----%@",[NSThread currentThread]);                  //列印當前執行緒
        }
    });
    
    DLog(@"syncConcurrent-------end");
}

輸出結果

從上面的列印結果來看 所有的任務都是在主執行緒中執行的, 沒有開啟新的執行緒

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

3.2 非同步執行 + 併發佇列

特點:可以開啟多個執行緒，任務交替（同時）執行。

/*
 非同步執行 + 併發佇列
 特點:可以開啟多個執行緒，任務交替（同時）執行。
 */
-(void)asyncConcurrent{
    DLog(@"currentThread----%@",[NSThread currentThread]);              //列印當前執行緒
    DLog(@"asyncConcurrent----begin");
    
    dispatch_queue_t queue = dispatch_queue_create("com.wangyu.cn.YukiFramework", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(queue, ^{
        //任務1
        for (int i = 0 ; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];                           // 模擬耗時操作
            DLog(@"1-----%@",[NSThread currentThread]);                  //列印當前執行緒
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; i++) {
            //任務2
            [NSThread sleepForTimeInterval:2];                          // 模擬耗時操作
            DLog(@"2----%@",[NSThread currentThread]);                  //列印當前執行緒
        }
    });
    
    dispatch_async(queue, ^{
       //任務3
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];                          // 模擬耗時操作
            DLog(@"3------%@",[NSThread currentThread]);                //列印當前執行緒
        }
    });
    
    DLog(@"asyncConcurrent----end");
}

列印效果如下

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

除了當前執行緒（主執行緒），系統又開啟了3個執行緒，並且任務是交替/同時執行的。（非同步執行具備開啟新執行緒的能力。且併發佇列可開啟多個執行緒，同時執行多個任務）。

所有任務是在列印的asyncConcurrent---begin和asyncConcurrent---end之後才執行的。說明當前執行緒沒有等待，而是直接開啟了新執行緒，在新執行緒中執行任務（非同步執行不做等待，可以繼續執行任務）。

3.3 同步執行 + 序列佇列

特點:不會開啟新的執行緒 在當前執行緒執行任務。任務是序列的，執行完一個任務，再執行下一個任務。

/*
 同步執行 + 序列佇列
 特點: 不會開啟新執行緒，在當前執行緒執行任務。任務是序列的，執行完一個任務，再執行下一個任務。
 */
-(void)syncSerial{
    DLog(@"currentThread----%@",[NSThread currentThread]);              //列印當前執行緒
    DLog(@"syncSerial----begin");
    
    dispatch_queue_t queue = dispatch_queue_create("com.wangyu.cn.YukiFramework", DISPATCH_QUEUE_SERIAL);
    
    dispatch_sync(queue, ^{
       //任務1
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];                          // 模擬耗時操作
            DLog(@"1-----%@",[NSThread currentThread]);                 //列印當前執行緒
        }
    });
    
    dispatch_sync(queue, ^{
       //任務2
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];                          // 模擬耗時操作
            DLog(@"2-----%@",[NSThread currentThread]);                 //列印當前執行緒
        }
    });
    
    dispatch_sync(queue, ^{
        //任務3
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];                          // 模擬耗時操作
            DLog(@"3-----%@",[NSThread currentThread]);                 //列印當前執行緒
        }
    });
    
    DLog(@"syncSerial----end");
}

列印結果

從上面我們可以看出 所有任務都是在當前執行緒（主執行緒）中執行的，並沒有開啟新的執行緒（同步執行不具備開啟新執行緒的能力）。

任務是按順序執行的（序列佇列每次只有一個任務被執行，任務一個接一個按順序執行）。

3.4 非同步執行 + 序列佇列

特點:會開啟新執行緒，但是因為任務是序列的，執行完一個任務，再執行下一個任務

/*
 非同步執行 + 序列佇列
 特點: 會開啟新的執行緒  但是因為任務是序列的 執行完一個任務 在執行下一個
 */
-(void)asyncSerial{
    DLog(@"currentThread----%@",[NSThread currentThread]);              //列印當前執行緒
    DLog(@"asyncSerial----begin");
    
    dispatch_queue_t queue = dispatch_queue_create("com.wangyu.cn.YukiFramework", DISPATCH_QUEUE_SERIAL);
    
    dispatch_async(queue, ^{
       //任務1
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];                          // 模擬耗時操作
            DLog(@"1-----%@",[NSThread currentThread]);                 //列印當前執行緒
        }
    });
    
    dispatch_async(queue, ^{
        //任務2
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];                          // 模擬耗時操作
            DLog(@"2-----%@",[NSThread currentThread]);                 //列印當前執行緒
        }
    });
    
    dispatch_async(queue, ^{
        //任務3
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];                          // 模擬耗時操作
            DLog(@"3-----%@",[NSThread currentThread]);                 //列印當前執行緒
        }
    });
    
    DLog(@"asyncSerial----end");
}

列印結果

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

啟了一條新執行緒（非同步執行具備開啟新執行緒的能力，序列佇列只開啟一個執行緒）。

所有任務是在列印的syncConcurrent---begin和syncConcurrent---end之後才開始執行的（非同步執行不會做任何等待，可以繼續執行任務）。

任務是按順序執行的（序列佇列每次只有一個任務被執行，任務一個接一個按順序執行）。

下面說說主佇列:

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

3.5同步執行 + 主佇列

在不同執行緒中呼叫結果也是不一樣，在主執行緒中呼叫會出現死鎖，而在其他執行緒中則不會。

3.5.1 在主執行緒中呼叫 同步執行 + 主佇列

互相等待卡住不可行

/*
 同步執行 + 主佇列
 特點(主執行緒呼叫): 互等卡主不執行, 都是大哥 互相禮讓就卡死了
 特點(其他執行緒呼叫) : 不會開啟新執行緒 執行完一個任務 在執行下一個任務
 */
-(void)syncMain{
    DLog(@"currentThread----%@",[NSThread currentThread]);              //列印當前執行緒
    DLog(@"syncMain----begin");
    
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    dispatch_sync(queue, ^{
        //任務1
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];                          // 模擬耗時操作
            DLog(@"1--------%@",[NSThread currentThread]);              //列印當前執行緒
        }
    });
    
    dispatch_sync(queue, ^{
        //任務2
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];                          // 模擬耗時操作
            DLog(@"2--------%@",[NSThread currentThread]);              //列印當前執行緒
        }
    });
    
    dispatch_sync(queue, ^{
        //任務3
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];                          // 模擬耗時操作
            DLog(@"3--------%@",[NSThread currentThread]);              //列印當前執行緒
        }
    });
    
    DLog(@"syncMain----end");
    
}

在主執行緒呼叫主佇列 直接卡死

在主執行緒中使用同步執行 + 主佇列，追加到主執行緒的任務1、任務2、任務3都不再執行了，而且syncMain---end也沒有列印，在XCode 9上還會報崩潰。這是為什麼呢？

這是因為我們在主執行緒中執行syncMain方法，相當於把syncMain任務放到了主執行緒的佇列中。而同步執行會等待當前佇列中的任務執行完畢，才會接著執行。那麼當我們把任務1追加到主佇列中，任務1就在等待主執行緒處理完syncMain任務。而syncMain任務需要等待任務1執行完畢，才能接著執行。

那麼，現在的情況就是syncMain任務和任務1都在等對方執行完畢。這樣大家互相等待，所以就卡住了，所以我們的任務執行不了，而且syncMain---end也沒有列印。

3.5.2 在其他執行緒中呼叫同步執行 + 主佇列

特點: 不會開啟新執行緒，執行完一個任務，再執行下一個任務

//    同步執行 + 主佇列(其他執行緒呼叫)
    [NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];

列印結果

3.5.3 非同步執行 + 主佇列

只在主執行緒中執行任務，執行完一個任務，再執行下一個任務。(即不會開啟新執行緒)

/*
 非同步執行 + 主佇列
 特點: 只在主執行緒中執行任務 執行完一個任務, 在執行下一個任務
 */
-(void)asyncMain{
    DLog(@"currentThread----%@",[NSThread currentThread]);              //列印當前執行緒
    DLog(@"asyncMain----begin");
    
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    dispatch_async(queue, ^{
        //任務1
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];                          // 模擬耗時操作
            DLog(@"1------%@",[NSThread currentThread]);                //列印當前執行緒
        }
    });
    
    dispatch_async(queue, ^{
        //任務2
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];                          // 模擬耗時操作
            DLog(@"2------%@",[NSThread currentThread]);                //列印當前執行緒
        }
    });
    
    dispatch_async(queue, ^{
        //任務3
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];                          // 模擬耗時操作
            DLog(@"3------%@",[NSThread currentThread]);                //列印當前執行緒
        }
    });
    
    DLog(@"asyncMain----end");
}

列印效果

在非同步執行 + 主佇列可以看到：
所有任務都是在當前執行緒（主執行緒）中執行的，並沒有開啟新的執行緒（雖然非同步執行具備開啟執行緒的能力，但因為是主佇列，所以所有任務都在主執行緒中）。

所有任務是在列印的syncConcurrent---begin和syncConcurrent---end之後才開始執行的（非同步執行不會做任何等待，可以繼續執行任務）。

任務是按順序執行的（因為主佇列是序列佇列，每次只有一個任務被執行，任務一個接一個按順序執行）。

綜上所述

同步執行 + 併發佇列
特點: 在當前執行緒中執行任務，不會開啟新執行緒，執行完一個任務，再執行下一個任務。
非同步執行 + 併發佇列
特點:可以開啟多個執行緒，任務交替（同時）執行。
同步執行 + 序列佇列
特點: 不會開啟新執行緒，在當前執行緒執行任務。任務是序列的，執行完一個任務，再執行下一個任務。
非同步執行 + 序列佇列
特點: 會開啟新的執行緒 但是因為任務是序列的 執行完一個任務 在執行下一個
同步執行 + 主佇列
特點(主執行緒呼叫): 互等卡主不執行, 都是大哥 互相禮讓就卡死了
特點(其他執行緒呼叫) : 不會開啟新執行緒 執行完一個任務 在執行下一個任務
非同步執行 + 主佇列
特點: 只在主執行緒中執行任務 執行完一個人任務, 在執行下一個任務

除了 非同步執行 + 併發佇列 裡面的執行緒是可以交替執行的之外 其他的都是需要執行完一個任務，再執行下一個任務。

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];                          // 模擬耗時操作
            DLog(@"1-----%@",[NSThread currentThread]);                 //列印當前執行緒
        }
        
        //回到主執行緒
        dispatch_async(mainQueue, ^{
            [NSThread sleepForTimeInterval:2];                           // 模擬耗時操作
            DLog(@"2------%@",[NSThread currentThread]);                 //列印當前執行緒
        });
    });
    
}

列印效果

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

4. GCD 的其他方法

4.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("com.wangyu.cn.YukiFramework", DISPATCH_QUEUE_CONCURRENT);
    //非同步才能體現出來
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; i++) {
            //任務1
            [NSThread sleepForTimeInterval:2];                          // 模擬耗時操作
            DLog(@"1-----%@",[NSThread currentThread]);                 //列印當前執行緒
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; i++) {
            //任務2
            [NSThread sleepForTimeInterval:2];                          // 模擬耗時操作
            DLog(@"2-----%@",[NSThread currentThread]);                 //列印當前執行緒
        }
    });
    
    dispatch_barrier_sync(queue, ^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];
            DLog(@"barrier------%@",[NSThread currentThread]);
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; i++) {
            //任務3
            [NSThread sleepForTimeInterval:2];                          // 模擬耗時操作
            DLog(@"3-----%@",[NSThread currentThread]);                 //列印當前執行緒
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; i++) {
            //任務4
            [NSThread sleepForTimeInterval:2];                          // 模擬耗時操作
            DLog(@"4-----%@",[NSThread currentThread]);                 //列印當前執行緒
        }
    });
}

列印結果

在dispatch_barrier_async執行結果中可以看出：
在執行完柵欄前面的操作之後，才執行柵欄操作，最後再執行柵欄後邊的操作。

4.2 GCD 延時執行方法：dispatch_after

特點就是程式碼延遲幾秒執行

/*
 延時執行方法 dispatch_after
 */
-(void)after{
    DLog(@"currentThread----%@",[NSThread currentThread]);              //列印當前執行緒
    DLog(@"after----begin");
    
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        DLog(@"after-----%@",[NSThread currentThread]);
    });
}

4.3GCD 一次性程式碼（只執行一次）

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

/*
 一次性程式碼執行(只會執行一次) dispatch_once (可以使用單例)
 */
-(void)once{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken,^{
        DLog(@"222222");
    });
}

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 (他的作用有點類似 for 迴圈) 在序列佇列中  在非同步或者併發佇列中他的優勢更能提現出來
 */
-(void)apply{
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    DLog(@"apply-----begin");
    dispatch_apply(6, queue, ^(size_t index) {
        DLog(@"%ld-----%@",index,[NSThread currentThread]);
    });
    DLog(@"apply-----end");
}

列印結果

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

4.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 回到當前執行緒繼續向下執行（會阻塞當前執行緒）。

4.5.1 dispatch_group_notify 不會阻塞當前執行緒

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

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

列印結果

從上面可以看出：
當所有任務都執行完成之後，才執行dispatch_group_notify block 中的任務。

4.5.2 dispatch_group_wait 會阻塞當前執行緒

特點:暫停當前執行緒（阻塞當前執行緒），等待指定的 group 中的任務執行完成後，才會往下繼續執行。 頁面會暫時卡住 等執行完上面的之後 就好了

/*
佇列組 dispatch_group_wait
 特點:等待上面的任務全部完成後悔往下繼續執行 (其目的就是阻塞當前執行緒)
 */
-(void)groupWait{
    DLog(@"currentThread-----%@",[NSThread currentThread]);                 //列印當前執行緒
    DLog(@"groupWait----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];                          // 模擬耗時操作
            DLog(@"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];                          // 模擬耗時操作
            DLog(@"2-----%@",[NSThread currentThread]);                 //列印當前執行緒
        }
    });
    
    //等待上面的任務全部完成後悔往下繼續執行 (其目的就是阻塞當前執行緒)
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    
    DLog(@"group-------end");
}

列印效果

從上面可以看出:
當所有任務執行完成之後，才執行 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{
    DLog(@"currentThread-----%@",[NSThread currentThread]);                 //列印當前執行緒
    DLog(@"groupEnterAndLeave----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];                          // 模擬耗時操作
            DLog(@"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];                          // 模擬耗時操作
            DLog(@"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_notify 中的任務。這裡的dispatch_group_enter、dispatch_group_leave組合，其實等同於dispatch_group_async。

4.5.4 Dispatch Semaphore 執行緒同步

我們來利用 Dispatch Semaphore 實現執行緒同步，將非同步執行任務轉換為同步執行任務。

/*
 semaphore 執行緒同步
 */
-(void)semaphore{
    DLog(@"currentThread-----%@",[NSThread currentThread]);                 //列印當前執行緒
    DLog(@"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];                                  // 模擬耗時操作
        DLog(@"1---------%@",[NSThread currentThread]);                     // 列印當前執行緒
        
        number = 100;
        
        dispatch_semaphore_signal(semaphore);
    });
    
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    DLog(@"semaphore---end,number = %zd",number);
//    semaphore---end,number = 100 列印的是這樣的, 說明是一起出來的
}

列印結果

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

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

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

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

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

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

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

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

/*
 非執行緒安全 不使用 semaphore
 初始化火車票數量 賣票視窗(非執行緒安全) 並開始賣票
 */
-(void)initTicketStatusNotSave{
    DLog(@"currentThread-----%@",[NSThread currentThread]);                 //列印當前執行緒
    DLog(@"initTicketStatusNotSave----begin");
    
    self.ticketSurplusCount = 50;
    
    //queue1 代表視窗1售賣火車票
    dispatch_queue_t queue1 = dispatch_queue_create("com.wangyu.cn.YukiFramework", DISPATCH_QUEUE_SERIAL);
    //queue2 代表視窗2 售賣火車票
    dispatch_queue_t queue2 = dispatch_queue_create("com.wangyu.cn.YukiFramework", DISPATCH_QUEUE_SERIAL);
    @weakify(self)
    dispatch_async(queue1, ^{
        @strongify(self)
        [self saleTicketNotSafe];
    });
    
    dispatch_async(queue2, ^{
        @strongify(self)
        [self saleTicketNotSafe];
    });
    
}

/*
 售賣火車票(非執行緒安全)
 */
-(void)saleTicketNotSafe{
    while (true) {
        if (self.ticketSurplusCount > 0) {
            self.ticketSurplusCount -- ;
            DLog(@"%@",[NSString stringWithFormat:@"剩餘票數:%d 視窗:%@",self.ticketSurplusCount,[NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        }else{
            DLog(@"所有火車票均已售完");
            break;
        }
    }
}

列印結果

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

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

dispatch_semaphore_t semapgoreLock;

/*
 執行緒安全:使用 samephore 加鎖
 初始化火車票數量、賣票視窗(執行緒安全)、並開始賣票
 */
-(void)initTicketStatusSave{
    DLog(@"currentThread-----%@",[NSThread currentThread]);                 //列印當前執行緒
    DLog(@"initTicketStatusSave----begin");
    
    self.ticketSurplusCount = 50;
    
    semapgoreLock = dispatch_semaphore_create(1);
    
    //queue1 代表視窗1售賣火車票
    dispatch_queue_t queue1 = dispatch_queue_create("com.wangyu.cn.YukiFramework", DISPATCH_QUEUE_SERIAL);
    //queue2 代表視窗2 售賣火車票
    dispatch_queue_t queue2 = dispatch_queue_create("com.wangyu.cn.YukiFramework", DISPATCH_QUEUE_SERIAL);
    
    @weakify(self)
    dispatch_async(queue1, ^{
        @strongify(self)
        [self saleTicketSafe];
    });
    
    dispatch_async(queue2, ^{
        @strongify(self)
        [self saleTicketSafe];
    });
}

/*
 售賣火車票(執行緒安全)
 */
-(void)saleTicketSafe{
    while (1) {
        //相等於加鎖
        dispatch_semaphore_wait(semapgoreLock, DISPATCH_TIME_FOREVER);
        if ( self.ticketSurplusCount > 0) { //如果有就繼續賣
            self.ticketSurplusCount -- ;
            DLog(@"%@",[NSString stringWithFormat:@"剩餘票數:%d 視窗:%@",self.ticketSurplusCount,[NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        }else{
            DLog(@"所有火車票賣完");
            //相當於解鎖
            dispatch_semaphore_signal(semapgoreLock);
            break;
        }
        
        //相當於解鎖
        dispatch_semaphore_signal(semapgoreLock);
    }
}

列印結果

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

相關程式碼已經傳到 GitHud 上Demo

本文摘自iOS多執行緒：『GCD』詳盡總結