iOS多線程之GCD

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

  • GCD是什么?
  • GCD任務(wù)和隊列
  • GCD創(chuàng)建和使用
  • GCD 線程間的通信
  • GCD常見問題以及解決

GCD是什么？

來一張官網(wǎng)的截圖：


image.png

翻譯：Grand Central Dispatch（GCD）包括語言功能，運行時庫和系統(tǒng)增強(qiáng)功能，可為macOS，iOS，watchOS和tvOS中多核硬件上的并發(fā)代碼執(zhí)行提供系統(tǒng)，全面的改進(jìn)

GCD意思就是 ‘強(qiáng)大的中央調(diào)度器’

GCD的優(yōu)點：

  • GCD 可用于多核的并行運算
  • GCD 會自動利用更多的 CPU 內(nèi)核
  • GCD 會自動管理線程的生命周期（創(chuàng)建線程、調(diào)度任務(wù)、銷毀線程）
  • 只需要告訴 GCD 想要執(zhí)行什么任務(wù)，不需要編寫任何線程管理代碼

GCD 任務(wù)和隊列

任務(wù):

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

  • 同步執(zhí)行（sync）

    • 同步添加任務(wù)到指定的隊列中，在添加的任務(wù)執(zhí)行結(jié)束之前，會一直等待，直到隊列里面的任務(wù)完成之后再繼續(xù)執(zhí)行。
      只能在當(dāng)前線程中執(zhí)行任務(wù)，不具備開啟新線程的能力。

  • 異步執(zhí)行（async）

    • 異步添加任務(wù)到指定的隊列中，它不會做任何等待，可以繼續(xù)執(zhí)行任務(wù)。
      可以在新的線程中執(zhí)行任務(wù)，具備開啟新線程的能力。

注意：是否等待隊列的任務(wù)執(zhí)行結(jié)束，以及是否具備開啟新線程的能力

隊列

在 GCD 中有兩種隊列：串行隊列和并發(fā)隊列。兩者都符合 FIFO（先進(jìn)先出）的原則。兩者的主要區(qū)別是：執(zhí)行順序不同，以及開啟線程數(shù)不同

  • 串行隊列

    • 每次只有一個任務(wù)被執(zhí)行。讓任務(wù)一個接著一個地執(zhí)行。一個任務(wù)執(zhí)行完畢后，再執(zhí)行下一個任務(wù)。

    • 只開啟一個新線程（或者不開啟新線程，在當(dāng)前線程執(zhí)行任務(wù)）。

  • 并發(fā)隊列

    • 可以讓多個任務(wù)并發(fā)（同時）執(zhí)行。
    • 可以開啟多個線程，并且同時執(zhí)行任務(wù)。

注意：并發(fā)隊列的并發(fā)功能只有在異步（dispatch_async）函數(shù)下才有效

串行隊列

并發(fā)隊列

GCD創(chuàng)建和使用

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

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

串行隊列又有一個隊列：

  • 主隊列

所有放在主隊列中的任務(wù)，都會放到主線程中執(zhí)行

// 主隊列的獲取方法
dispatch_queue_t queue = dispatch_get_main_queue();

并發(fā)隊列又有一個隊列：

  • 全局并發(fā)隊列

可以使用dispatch_get_global_queue來獲取。需要傳入兩個參數(shù)。第一個參數(shù)表示隊列優(yōu)先級，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二個參數(shù)暫時沒用，用0即可

// 全局并發(fā)隊列的獲取方法
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
任務(wù)的創(chuàng)建

GCD 提供了同步執(zhí)行任務(wù)的創(chuàng)建方法dispatch_sync和異步執(zhí)行任務(wù)創(chuàng)建方法dispatch_async

// 同步執(zhí)行任務(wù)創(chuàng)建方法
dispatch_sync(queue, ^{
    // 這里放同步執(zhí)行任務(wù)代碼
});
// 異步執(zhí)行任務(wù)創(chuàng)建方法
dispatch_async(queue, ^{
    // 這里放異步執(zhí)行任務(wù)代碼
});

好了現(xiàn)在 幾種隊列已經(jīng)知道了，幾種執(zhí)行方式也知道了。那么他們之間的排列組合分別是：

  • 同步執(zhí)行 + 并發(fā)隊列
  • 異步執(zhí)行 + 并發(fā)隊列
  • 同步執(zhí)行 + 串行隊列
  • 異步執(zhí)行 + 串行隊列
  • 同步執(zhí)行 + 主隊列

  • 異步執(zhí)行 + 主隊列
    以下是同步異步隊列的關(guān)系


    image.png

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

同步執(zhí)行 + 并發(fā)隊列
/**
 * 同步執(zhí)行 + 并發(fā)隊列
 * 特點：在當(dāng)前線程中執(zhí)行任務(wù)，不會開啟新線程，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。
 */
- (void)syncConcurrent {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    NSLog(@"syncConcurrent---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("JFTestQueue", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_sync(queue, ^{
        // 追加任務(wù)1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    dispatch_sync(queue, ^{
        // 追加任務(wù)2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    dispatch_sync(queue, ^{
        // 追加任務(wù)3
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    NSLog(@"syncConcurrent---end");
}
image.png

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

異步執(zhí)行 + 并發(fā)隊列
/**
/**
 * 異步執(zhí)行 + 并發(fā)隊列
 * 特點：可以開啟多個線程，任務(wù)交替（同時）執(zhí)行。
 */
- (void)asyncConcurrent {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    NSLog(@"asyncConcurrent---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("JFTestQueue", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(queue, ^{
        // 追加任務(wù)1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    dispatch_async(queue, ^{
        // 追加任務(wù)2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    dispatch_async(queue, ^{
        // 追加任務(wù)3
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    NSLog(@"asyncConcurrent---end");
}
image.png

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

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

同步執(zhí)行 + 串行隊列
/**
 * 同步執(zhí)行 + 串行隊列
 * 特點：不會開啟新線程，在當(dāng)前線程執(zhí)行任務(wù)。任務(wù)是串行的，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。
 */
- (void)syncSerial {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    NSLog(@"syncSerial---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("JFTestQueue", DISPATCH_QUEUE_SERIAL);
    
    dispatch_sync(queue, ^{
        // 追加任務(wù)1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    dispatch_sync(queue, ^{
        // 追加任務(wù)2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    dispatch_sync(queue, ^{
        // 追加任務(wù)3
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    NSLog(@"syncSerial---end");
}
image.png
  • 所有任務(wù)都是在當(dāng)前線程（主線程）中執(zhí)行的，并沒有開啟新的線程（同步執(zhí)行不具備開啟新線程的能力）。
  • 所有任務(wù)都在打印的syncConcurrent---begin和syncConcurrent---end之間執(zhí)行（同步任務(wù)需要等待隊列的任務(wù)執(zhí)行結(jié)束）。
  • 任務(wù)是按順序執(zhí)行的（串行隊列每次只有一個任務(wù)被執(zhí)行，任務(wù)一個接一個按順序執(zhí)行）。
異步執(zhí)行 + 串行隊列
/**
 * 異步執(zhí)行 + 串行隊列
 * 特點：會開啟新線程，但是因為任務(wù)是串行的，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。
 */
- (void)asyncSerial {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    NSLog(@"asyncSerial---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("JFTestQueue", DISPATCH_QUEUE_SERIAL);
    
    dispatch_async(queue, ^{
        // 追加任務(wù)1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    dispatch_async(queue, ^{
        // 追加任務(wù)2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    dispatch_async(queue, ^{
        // 追加任務(wù)3
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    NSLog(@"asyncSerial---end");
}
image.png
  • 開啟了一條新線程（異步執(zhí)行具備開啟新線程的能力，串行隊列只開啟一個線程）。
  • 所有任務(wù)是在打印的syncConcurrent---begin和syncConcurrent---end之后才開始執(zhí)行的（異步執(zhí)行不會做任何等待，可以繼續(xù)執(zhí)行任務(wù)）。
  • 任務(wù)是按順序執(zhí)行的（串行隊列每次只有一個任務(wù)被執(zhí)行，任務(wù)一個接一個按順序執(zhí)行）。
同步執(zhí)行 + 主隊列

同步執(zhí)行 + 主隊列 主線程

/**
 * 同步執(zhí)行 + 主隊列
 * 特點(主線程調(diào)用)：互等卡主不執(zhí)行。
 * 特點(其他線程調(diào)用)：不會開啟新線程，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。
 */
- (void)syncMain {
    
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    NSLog(@"syncMain---begin");
    
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    dispatch_sync(queue, ^{
        // 追加任務(wù)1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    dispatch_sync(queue, ^{
        // 追加任務(wù)2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    dispatch_sync(queue, ^{
        // 追加任務(wù)3
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    NSLog(@"syncMain---end");
}
image.png
image.png

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

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

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

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

在其他線程中調(diào)用 同步執(zhí)行 + 主隊列 在其他線程

    // 使用 NSThread 的 detachNewThreadSelector 方法會創(chuàng)建線程，并自動啟動線程執(zhí)行
//    selector 任務(wù)
    [NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];
image.png

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

異步執(zhí)行 + 主隊列
 NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    NSLog(@"asyncMain---begin");
    
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    dispatch_async(queue, ^{
        // 追加任務(wù)1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    dispatch_async(queue, ^{
        // 追加任務(wù)2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    dispatch_async(queue, ^{
        // 追加任務(wù)3
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    NSLog(@"asyncMain---end");
}
image.png

打印如上

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

GCD 柵欄方法

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

/**
 * 柵欄方法 dispatch_barrier_async
 */
- (void)barrier {
    dispatch_queue_t queue = dispatch_queue_create("JFTestQueue", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(queue, ^{
        // 追加任務(wù)1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    dispatch_async(queue, ^{
        // 追加任務(wù)2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    dispatch_barrier_async(queue, ^{
        // 追加任務(wù) barrier
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"barrier---%@",[NSThread currentThread]);// 打印當(dāng)前線程
        }
    });
    
    dispatch_async(queue, ^{
        // 追加任務(wù)3
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    dispatch_async(queue, ^{
        // 追加任務(wù)4
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"4---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
}
image.png

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

GCD 延時執(zhí)行方法：dispatch_after
我們經(jīng)常會遇到這樣的需求：在指定時間（例如3秒）之后執(zhí)行某個任務(wù)。可以用 GCD 的dispatch_after函數(shù)來實現(xiàn)。
需要注意的是：dispatch_after函數(shù)并不是在指定時間之后才開始執(zhí)行處理，而是在指定時間之后將任務(wù)追加到主隊列中。嚴(yán)格來說，這個時間并不是絕對準(zhǔn)確的，但想要大致延遲執(zhí)行任務(wù)，dispatch_after函數(shù)是很有效的

/**
 * 延時執(zhí)行方法 dispatch_after
 */
- (void)after {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    NSLog(@"asyncMain---begin");
    
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        // 2.0秒后異步追加任務(wù)代碼到主隊列，并開始執(zhí)行
        NSLog(@"after---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    });
}

GCD 一次性代碼（只執(zhí)行一次）：dispatch_once

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

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

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

  • 調(diào)用隊列組的 dispatch_group_async 先把任務(wù)放到隊列中，然后將隊列放入隊列組中?；蛘呤褂藐犃薪M的 dispatch_group_enter、dispatch_group_leave 組合 來實現(xiàn)
    dispatch_group_async。
  • 調(diào)用隊列組的 dispatch_group_notify 回到指定線程執(zhí)行任務(wù)?；蛘呤褂?dispatch_group_wait 回到當(dāng)前線程繼續(xù)向下執(zhí)行（會阻塞當(dāng)前線程）。
    dispatch_group_notify
/**
 * 隊列組 dispatch_group_notify
 */
- (void)groupNotify {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    NSLog(@"group---begin");
    
    dispatch_group_t group =  dispatch_group_create();
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任務(wù)1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任務(wù)2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的異步任務(wù)1、任務(wù)2都執(zhí)行完畢后，回到主線程執(zhí)行下邊任務(wù)
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
        NSLog(@"group---end");
    });
}
image.png

從dispatch_group_notify相關(guān)代碼運行輸出結(jié)果可以看出：
當(dāng)所有任務(wù)都執(zhí)行完成之后，才執(zhí)行dispatch_group_notify block 中的任務(wù)

dispatch_group_wait
暫停當(dāng)前線程（阻塞當(dāng)前線程），等待指定的 group 中的任務(wù)執(zhí)行完成后，才會往下繼續(xù)執(zhí)行

/**
 * 隊列組 dispatch_group_wait
 */
- (void)groupWait {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    NSLog(@"group---begin");
    
    dispatch_group_t group =  dispatch_group_create();
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任務(wù)1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任務(wù)2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
    });
    
    // 等待上面的任務(wù)全部完成后，會往下繼續(xù)執(zhí)行（會阻塞當(dāng)前線程）
    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 標(biāo)志著一個任務(wù)追加到 group，執(zhí)行一次，相當(dāng)于 group 中未執(zhí)行完畢任務(wù)數(shù)+1
  • dispatch_group_leave 標(biāo)志著一個任務(wù)離開了 group，執(zhí)行一次，相當(dāng)于 group 中未執(zhí)行完畢任務(wù)數(shù)-1。
  • 當(dāng) group 中未執(zhí)行完畢任務(wù)數(shù)為0的時候，才會使dispatch_group_wait解除阻塞，以及執(zhí)行追加到dispatch_group_notify中的任務(wù)。
/**
 * 隊列組 dispatch_group_enter、dispatch_group_leave
 */
- (void)groupEnterAndLeave
{
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    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, ^{
        // 追加任務(wù)1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
        dispatch_group_leave(group);
    });
    
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        // 追加任務(wù)2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
        dispatch_group_leave(group);
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的異步操作都執(zhí)行完畢后，回到主線程.
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印當(dāng)前線程
        }
        NSLog(@"group---end");
    });
    
//    // 等待上面的任務(wù)全部完成后，會往下繼續(xù)執(zhí)行（會阻塞當(dāng)前線程）
//    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
//
//    NSLog(@"group---end");
}

image.png

從dispatch_group_enter、dispatch_group_leave相關(guān)代碼運行結(jié)果中可以看出：當(dāng)所有任務(wù)執(zhí)行完成之后，才執(zhí)行 dispatch_group_notify中的任務(wù)。這里的dispatch_group_enter、dispatch_group_leave組合，其實等同于dispatch_group_async

GCD 信號量：dispatch_semaphore
GCD 中的信號量是指 Dispatch Semaphore，是持有計數(shù)的信號。類似于過高速路收費站的欄桿?？梢酝ㄟ^時，打開欄桿，不可以通過時，關(guān)閉欄桿。在 Dispatch Semaphore 中，使用計數(shù)來完成這個功能，計數(shù)為0時等待，不可通過。計數(shù)為1或大于1時，計數(shù)減1且不等待，可通過。
Dispatch Semaphore 提供了三個函數(shù)。

  • dispatch_semaphore_create：創(chuàng)建一個Semaphore并初始化信號的總量
  • dispatch_semaphore_signal：發(fā)送一個信號，讓信號總量加1
  • dispatch_semaphore_wait：可以使總信號量減1，當(dāng)信號總量為0時就會一直等待（阻塞所在線程），否則就可以正常執(zhí)行。

注意：信號量的使用前提是：想清楚你需要處理哪個線程等待（阻塞），又要哪個線程繼續(xù)執(zhí)行，然后使用信號量
Dispatch Semaphore 在實際開發(fā)中主要用于：

  • 保持線程同步，將異步執(zhí)行任務(wù)轉(zhuǎn)換為同步執(zhí)行任務(wù)

  • 保證線程安全，為線程加鎖


    image.png

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

/**
 * 非線程安全：不使用 semaphore
 * 初始化彩票數(shù)量、賣票窗口(非線程安全)、并開始賣票
 */
- (void)initTicketStatusNotSave {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    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) {  //如果還有票，繼續(xù)售賣
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩余票數(shù)：%d 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        } else { //如果已賣完，關(guān)閉售票窗口
            NSLog(@"所有彩票均已售完");
            break;
        }
        
    }
}
image.png

打印如上：數(shù)據(jù)是錯亂的

線程安全（使用 semaphore 加鎖）


/**
 * 線程安全：使用 semaphore 加鎖
 * 初始化彩票數(shù)量、賣票窗口(線程安全)、并開始賣票
 */
- (void)initTicketStatusSave {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印當(dāng)前線程
    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) {
        // 相當(dāng)于加鎖
        dispatch_semaphore_wait(semaphoreLock, DISPATCH_TIME_FOREVER);
        
        if (self.ticketSurplusCount > 0) {  //如果還有票，繼續(xù)售賣
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩余票數(shù)：%d 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        } else { //如果已賣完，關(guān)閉售票窗口
            NSLog(@"所有彩均已售完");
            
            // 相當(dāng)于解鎖
            dispatch_semaphore_signal(semaphoreLock);
            break;
        }
        
        // 相當(dāng)于解鎖
        dispatch_semaphore_signal(semaphoreLock);
    }
}
image.png

打印如上枷鎖之后的數(shù)據(jù)就正常了

GCD常見問題以及解決

  • 線程死鎖

死鎖原因：
所謂死鎖，通常指有兩個線程A和B都卡住了，并等待對方完成某些操作。A不能完成是因為它在等待B完成。但B也不能完成，因為它在等待A完成。于是大家都完不成，就導(dǎo)致了死鎖（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

同步主隊列導(dǎo)致線程死鎖

一定要避免dispatch_apply的嵌套調(diào)用。

  • 線程不安全
    線程不安全是由于多線程訪問造成的
    解決：
    1.既然線程安全問題是由多線程引起的，那么，最極端的可以使用單線程保證線程安全。
    2.線程安全是由于多線程訪問和修改共享資源而引起不可預(yù)測的結(jié)果，因此，如果都是訪問共享資源而不去修改共享資源也可以保證線程安全，比如：設(shè)置只讀屬性的全局變量。
    3.使用鎖。（上面已經(jīng)說到了）
  • dispatch_once_t必須是全局或static變量
    //靜態(tài)變量，保證只有一份實例，才能確保只執(zhí)行一次
  • dispatch_after是延遲提交，不是延遲運行
Enqueue a block for execution at the specified time.

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

  • 如何正確創(chuàng)建dispatch_time_t 
1. dispatch_time(<#dispatch_time_t when#>, <#int64_t delta#>)
        第一個參數(shù)是從什么時間開始,一般直接傳 DISPATCH_TIME_NOW; 表示從現(xiàn)在開始
        第二個參數(shù)表示具體的時間長度(不能直接傳 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#>),
        第一個參數(shù)是一個結(jié)構(gòu)體, 創(chuàng)建的是一個絕對的時間點,比如 2016年10月10日8點30分30秒, 如果你不需要自某一個特定的時刻開始,可以傳 NUll,表示自動獲取當(dāng)前時區(qū)的當(dāng)前時間作為開始時刻, 第二參數(shù)意義同第一個函數(shù)
        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/
注：本文參考如上兩篇文章，如造成商業(yè)侵權(quán)望告知，并修改

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

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

  • 1. GCD簡介 什么是GCD呢？我們先來看看百度百科的解釋簡單了解下概念 引自百度百科：Grand Centra...
    千尋_544f閱讀 495評論 0贊 0
  • 本文首發(fā)于我的個人博客：「程序員充電站」[https://itcharge.cn]文章鏈接：「傳送門」[https...
    ITCharge閱讀 350,585評論 308贊 1,928
  • 晚上7點多，還有好幾件必須今天完成的事要做——明天休息，拖到后天就顯得比較遲了，所以今天無論如何也得做完了再下班。...
    張露deer閱讀 187評論 0贊 0
  • 【0503晨讀感想】 對癥下藥方能解病 今天晚上又玻璃心的哭了，被老大說了，自己覺得氣不過就反駁了幾句，可能有點口...
    小二關(guān)閱讀 162評論 0贊 0
  • 高效能人生的睡眠 早睡為了身體 早起為了心靈 高效能人生的睡眠 在于早睡早起的關(guān)鍵 重點是睡眠質(zhì)量 而不是睡眠時間...
    海盜baby閱讀 307評論 0贊 0

友情鏈接更多精彩內(nèi)容