日韩精品一区二区三区色欲av,人人妻人人澡人人爽超污,真人作爱免费视频

繼上一篇說到的NSTread之后本文主要分享下GCD的一些總結主要是按一下幾點進行：

GCD是什么?
GCD任務和隊列
GCD創建和使用
GCD 線程間的通信
GCD常見問題以及解決

GCD是什么？

來一張官網的截圖：

image.png

翻譯：Grand Central Dispatch（GCD）包括語言功能，運行時庫和系統增強功能，可為macOS，iOS，watchOS和tvOS中多核硬件上的并發代碼執行提供系統，全面的改進

GCD意思就是 ‘強大的中央調度器’

`GCD的優點：`

GCD 可用于多核的并行運算
GCD 會自動利用更多的 CPU 內核
GCD 會自動管理線程的生命周期（創建線程、調度任務、銷毀線程）
只需要告訴 GCD 想要執行什么任務，不需要編寫任何線程管理代碼

GCD 任務和隊列

任務:

就是執行操作的意思，換句話說就是你在線程中執行的那段代碼。在 GCD 中是放在 block 中的。執行任務有兩種方式：

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

注意：是否等待隊列的任務執行結束，以及是否具備開啟新線程的能力

隊列

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

串行隊列
- 每次只有一個任務被執行。讓任務一個接著一個地執行。一個任務執行完畢后，再執行下一個任務。
- 只開啟一個新線程（或者不開啟新線程，在當前線程執行任務）。
并發隊列
- 可以讓多個任務并發（同時）執行。
- 可以開啟多個線程，并且同時執行任務。

注意：并發隊列的并發功能只有在異步（dispatch_async）函數下才有效

串行隊列

并發隊列

GCD創建和使用

可以用dispatch_queue_create來創建第一個參數是標識，第二個參數是隊列類型分別是：DISPATCH_QUEUE_SERIAL 和 DISPATCH_QUEUE_CONCURRENT
SERIAL的中文意思是 串行
CONCURRENT 的中文意思是并發
這樣就好好理解了

// 串行隊列的創建方法
dispatch_queue_t queue = dispatch_queue_create("JFTestQueue", DISPATCH_QUEUE_SERIAL);
// 并發隊列的創建方法
dispatch_queue_t queue = dispatch_queue_create("JFTestQueue", DISPATCH_QUEUE_CONCURRENT);

串行隊列又有一個隊列：

主隊列

所有放在主隊列中的任務，都會放到主線程中執行

// 主隊列的獲取方法
dispatch_queue_t queue = dispatch_get_main_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, ^{
    // 這里放異步執行任務代碼
});

好了現在幾種隊列已經知道了，幾種執行方式也知道了。那么他們之間的排列組合分別是：

同步執行 + 并發隊列
異步執行 + 并發隊列
同步執行 + 串行隊列
異步執行 + 串行隊列
同步執行 + 主隊列
異步執行 + 主隊列
以下是同步異步隊列的關系

image.png

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

同步執行 + 并發隊列

/**
 * 同步執行 + 并發隊列
 * 特點：在當前線程中執行任務，不會開啟新線程，執行完一個任務，再執行下一個任務。
 */
- (void)syncConcurrent {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當前線程
    NSLog(@"syncConcurrent---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("JFTestQueue", 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");
}

image.png

打印如上：都在同一個線程中執行，且是執行完一個任務后再執行另一個任務

異步執行 + 并發隊列

/**
/**
 * 異步執行 + 并發隊列
 * 特點：可以開啟多個線程，任務交替（同時）執行。
 */
- (void)asyncConcurrent {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當前線程
    NSLog(@"asyncConcurrent---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("JFTestQueue", 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");
}

image.png

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

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

同步執行 + 串行隊列

/**
 * 同步執行 + 串行隊列
 * 特點：不會開啟新線程，在當前線程執行任務。任務是串行的，執行完一個任務，再執行下一個任務。
 */
- (void)syncSerial {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當前線程
    NSLog(@"syncSerial---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("JFTestQueue", 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");
}

image.png

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

異步執行 + 串行隊列

/**
 * 異步執行 + 串行隊列
 * 特點：會開啟新線程，但是因為任務是串行的，執行完一個任務，再執行下一個任務。
 */
- (void)asyncSerial {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當前線程
    NSLog(@"asyncSerial---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("JFTestQueue", 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");
}

image.png

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

同步執行 + 主隊列

同步執行 + 主隊列 主線程

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

image.png

打印和運行如上截圖奔潰了

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

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

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

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

    // 使用 NSThread 的 detachNewThreadSelector 方法會創建線程，并自動啟動線程執行
//    selector 任務
    [NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];

image.png

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

異步執行 + 主隊列

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

image.png

打印如上

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

GCD 柵欄方法

我們有時需要異步執行兩組操作，而且第一組操作執行完之后，才能開始執行第二組操作。這樣我們就需要一個相當于柵欄一樣的一個方法將兩組異步執行的操作組給分割起來，當然這里的操作組里可以包含一個或多個任務。這就需要用到dispatch_barrier_async方法在兩個操作組間形成柵欄。
dispatch_barrier_async函數會等待前邊追加到并發隊列中的任務全部執行完畢之后，再將指定的任務追加到該異步隊列中。然后在dispatch_barrier_async函數追加的任務執行完畢之后，異步隊列才恢復為一般動作，接著追加任務到該異步隊列并開始執行

/**
 * 柵欄方法 dispatch_barrier_async
 */
- (void)barrier {
    dispatch_queue_t queue = dispatch_queue_create("JFTestQueue", 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]);      // 打印當前線程
        }
    });
}

image.png

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

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

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

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

GCD 快速迭代方法：dispatch_apply

/**
 * 快速迭代方法 dispatch_apply
 */
- (void)apply {
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    NSLog(@"apply---begin");
    dispatch_apply(6, queue, ^(size_t index) {
        NSLog(@"%zd---%@",index, [NSThread currentThread]);
    });
    NSLog(@"apply---end");
}

image.png

因為是在并發隊列中異步隊執行任務，所以各個任務的執行時間長短不定，最后結束順序也不定。但是apply---end一定在最后執行。這是因為dispatch_apply函數會等待全部任務執行完畢
GCD 的隊列組：dispatch_group
有時候我們會有這樣的需求：分別異步執行2個耗時任務，然后當2個耗時任務都執行完畢后再回到主線程執行任務。這時候我們可以用到 GCD 的隊列組

調用隊列組的 dispatch_group_async 先把任務放到隊列中，然后將隊列放入隊列組中。或者使用隊列組的 dispatch_group_enter、dispatch_group_leave 組合來實現
dispatch_group_async。
調用隊列組的 dispatch_group_notify 回到指定線程執行任務。或者使用 dispatch_group_wait 回到當前線程繼續向下執行（會阻塞當前線程）。
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
        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");
    });
}

image.png

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

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

image.png

dispatch_group_enter、dispatch_group_leave
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");
}

image.png

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

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 在實際開發中主要用于：

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

image.png

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

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

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

image.png

打印如上：數據是錯亂的

線程安全（使用 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("JFTestestQueue1", DISPATCH_QUEUE_SERIAL);
    // queue2 代表足球彩票售賣窗口
    dispatch_queue_t queue2 = dispatch_queue_create("JFTestestQueue2", DISPATCH_QUEUE_SERIAL);
    
    __weak typeof(self) weakSelf = self;
    dispatch_async(queue1, ^{
        [weakSelf saleTicketSafe];
    });
    
    dispatch_async(queue2, ^{
        [weakSelf saleTicketSafe];
    });
}

/**
 * 售賣火車票(線程安全)
 */
- (void)saleTicketSafe {
    while (1) {
        // 相當于加鎖
        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);
    }
}

image.png

打印如上枷鎖之后的數據就正常了

GCD常見問題以及解決

線程死鎖

死鎖原因：
所謂死鎖，通常指有兩個線程A和B都卡住了，并等待對方完成某些操作。A不能完成是因為它在等待B完成。但B也不能完成，因為它在等待A完成。于是大家都完不成，就導致了死鎖（DeadLock）。

死鎖的例子

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

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

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

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

解決：

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

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

回顧下上面的表格：

image.png

同步主隊列導致線程死鎖

一定要避免dispatch_apply的嵌套調用。

線程不安全
線程不安全是由于多線程訪問造成的
解決：
1.既然線程安全問題是由多線程引起的，那么，最極端的可以使用單線程保證線程安全。
2.線程安全是由于多線程訪問和修改共享資源而引起不可預測的結果，因此，如果都是訪問共享資源而不去修改共享資源也可以保證線程安全，比如：設置只讀屬性的全局變量。
3.使用鎖。（上面已經說到了）

dispatch_once_t必須是全局或static變量
//靜態變量，保證只有一份實例，才能確保只執行一次

dispatch_after是延遲提交，不是延遲運行

Enqueue a block for execution at the specified time.

Enqueue，就是入隊，指的就是將一個Block在特定的延時以后，加入到指定的隊列中，不是在特定的時間后立即運行！

如何正確創建dispatch_time_t

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

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

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

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

iOS多線程之GCD

iOS多線程之GCD

GCD是什么？

`GCD的優點：`

GCD 任務和隊列

任務:

隊列

GCD創建和使用

任務的創建

同步執行 + 并發隊列

異步執行 + 并發隊列

同步執行 + 串行隊列

異步執行 + 串行隊列

同步執行 + 主隊列

異步執行 + 主隊列

GCD 柵欄方法

GCD常見問題以及解決

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

iOS多線程之GCD

GCD是什么？

GCD的優點：

GCD 任務和隊列

任務:

隊列

GCD創建和使用

任務的創建

同步執行 + 并發隊列

異步執行 + 并發隊列

同步執行 + 串行隊列

異步執行 + 串行隊列

同步執行 + 主隊列

異步執行 + 主隊列

GCD 柵欄方法

GCD常見問題以及解決

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

`GCD的優點：`