iOS多線程GCD的使用

来源:https://www.cnblogs.com/jukaiit/archive/2018/11/29/10038213.html
-Advertisement-
Play Games

1. GCD 簡介 Grand Central Dispatch（GCD）是非同步執行任務的技術之一。一般將應用程式中記述的線程管理用的代碼在系統級中實現。開發者只需要定義想執行的任務並追加到適當的Dispatch Queue中，GCD就能生成必要的線程並計劃執行任務。由於線程管理是作為系統的一部分來 ...


1. GCD 簡介

Grand Central Dispatch（GCD）是非同步執行任務的技術之一。一般將應用程式中記述的線程管理用的代碼在系統級中實現。開發者只需要定義想執行的任務並追加到適當的Dispatch Queue中，GCD就能生成必要的線程並計劃執行任務。由於線程管理是作為系統的一部分來實現的，因此可統一管理，也可執行任務，這樣就比以前的線程更有效率。

為什麼要用 GCD 呢？

因為 GCD 有很多好處啊，具體如下：

  • GCD 可用於多核的並行運算
  • GCD 會自動利用更多的 CPU 內核（比如雙核、四核）
  • GCD 會自動管理線程的生命周期（創建線程、調度任務、銷毀線程）
  • 程式員只需要告訴 GCD 想要執行什麼任務，不需要編寫任何線程管理代碼

既然 GCD 有這麼多的好處，那麼下麵我們就來系統的學習一下 GCD 的使用方法。



2. GCD 任務和隊列

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

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

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

舉個簡單例子：你要打電話給小明和小白。
同步執行就是，你打電話給小明的時候，不能同時打給小白，等到給小明打完了，才能打給小白（等待任務執行結束）。而且只能用當前的電話（不具備開啟新線程的能力）。
而非同步執行就是，你打電話給小明的時候，不等和小明通話結束，還能直接給小白打電話，不用等著和小明通話結束再打（不用等待任務執行結束）。除了當前電話，你還可以使用其他所能使用的電話（具備開啟新線程的能力）。

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

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

  隊列(Dispatch Queue).png

 

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

  • 串列隊列（Serial Dispatch Queue）：
    • 每次只有一個任務被執行。讓任務一個接著一個地執行。（只開啟一個線程，一個任務執行完畢後，再執行下一個任務）
  • 併發隊列（Concurrent Dispatch Queue）：
    • 可以讓多個任務併發（同時）執行。（可以開啟多個線程，並且同時執行任務）

註意：併發隊列的併發功能只有在非同步（dispatch_async）函數下才有效

兩者具體區別如下兩圖所示。

  串列隊列.png   併發隊列.png

3. GCD 的使用步驟

GCD 的使用步驟其實很簡單，只有兩步。

  1. 創建一個隊列（串列隊列或併發隊列）
  2. 將任務追加到任務的等待隊列中，然後系統就會根據任務類型執行任務（同步執行或非同步執行）

下邊來看看隊列的創建方法/獲取方法，以及任務的創建方法。

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

  • 可以使用dispatch_queue_create來創建隊列，需要傳入兩個參數，第一個參數表示隊列的唯一標識符，用於 DEBUG，可為空，Dispatch Queue 的名稱推薦使用應用程式 ID 這種逆序全程功能變數名稱；第二個參數用來識別是串列隊列還是併發隊列。DISPATCH_QUEUE_SERIAL表示串列隊列，DISPATCH_QUEUE_CONCURRENT表示併發隊列。
// 串列隊列的創建方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
// 併發隊列的創建方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
  • 對於串列隊列，GCD 提供了的一種特殊的串列隊列：主隊列（Main Dispatch Queue）。
    • 所有放在主隊列中的任務，都會放到主線程中執行。
    • 可使用dispatch_get_main_queue()獲得主隊列。
// 主隊列的獲取方法
dispatch_queue_t queue = dispatch_get_main_queue();
  • 對於併發隊列，GCD 預設提供了全局併發隊列（Global Dispatch Queue）。
    • 可以使用dispatch_get_global_queue來獲取。需要傳入兩個參數。第一個參數表示隊列優先順序，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二個參數暫時沒用，用0即可。
// 全局併發隊列的獲取方法
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

3.2 任務的創建方法

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

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

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

  1. 同步執行 + 併發隊列
  2. 非同步執行 + 併發隊列
  3. 同步執行 + 串列隊列
  4. 非同步執行 + 串列隊列

實際上，剛纔還說了兩種特殊隊列：全局併發隊列、主隊列。全局併發隊列可以作為普通併發隊列來使用。但是主隊列因為有點特殊，所以我們就又多了兩種組合方式。這樣就有六種不同的組合方式了。

  1. 同步執行 + 主隊列
  2. 非同步執行 + 主隊列

那麼這幾種不同組合方式各有什麼區別呢，這裡為了方便，先上結果，再來講解。你可以直接查看表格結果，然後跳過 4. GCD的基本使用。

區別併發隊列串列隊列主隊列
同步(sync) 沒有開啟新線程，串列執行任務 沒有開啟新線程，串列執行任務 主線程調用：死鎖卡住不執行
其他線程調用：沒有開啟新線程，串列執行任務
非同步(async) 有開啟新線程，併發執行任務 有開啟新線程(1條)，串列執行任務 沒有開啟新線程，串列執行任務

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

4. GCD 的基本使用

先來講講併發隊列的兩種執行方式。

4.1 同步執行 + 併發隊列

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

輸出結果：
2018-02-23 20:34:55.095932+0800 YSC-GCD-demo[19892:4996930] currentThread---<NSThread: 0x60400006bbc0>{number = 1, name = main}
2018-02-23 20:34:55.096086+0800 YSC-GCD-demo[19892:4996930] syncConcurrent---begin
2018-02-23 20:34:57.097589+0800 YSC-GCD-demo[19892:4996930] 1---<NSThread: 0x60400006bbc0>{number = 1, name = main}
2018-02-23 20:34:59.099100+0800 YSC-GCD-demo[19892:4996930] 1---<NSThread: 0x60400006bbc0>{number = 1, name = main}
2018-02-23 20:35:01.099843+0800 YSC-GCD-demo[19892:4996930] 2---<NSThread: 0x60400006bbc0>{number = 1, name = main}
2018-02-23 20:35:03.101171+0800 YSC-GCD-demo[19892:4996930] 2---<NSThread: 0x60400006bbc0>{number = 1, name = main}
2018-02-23 20:35:05.101750+0800 YSC-GCD-demo[19892:4996930] 3---<NSThread: 0x60400006bbc0>{number = 1, name = main}
2018-02-23 20:35:07.102414+0800 YSC-GCD-demo[19892:4996930] 3---<NSThread: 0x60400006bbc0>{number = 1, name = main}
2018-02-23 20:35:07.102575+0800 YSC-GCD-demo[19892:4996930] syncConcurrent---end

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

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

4.2 非同步執行 + 併發隊列

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

輸出結果：
2018-02-23 20:36:41.769269+0800 YSC-GCD-demo[19929:5005237] currentThread---<NSThread: 0x604000062d80>{number = 1, name = main}
2018-02-23 20:36:41.769496+0800 YSC-GCD-demo[19929:5005237] asyncConcurrent---begin
2018-02-23 20:36:41.769725+0800 YSC-GCD-demo[19929:5005237] asyncConcurrent---end
2018-02-23 20:36:43.774442+0800 YSC-GCD-demo[19929:5005566] 2---<NSThread: 0x604000266f00>{number = 5, name = (null)}
2018-02-23 20:36:43.774440+0800 YSC-GCD-demo[19929:5005567] 3---<NSThread: 0x60000026f200>{number = 4, name = (null)}
2018-02-23 20:36:43.774440+0800 YSC-GCD-demo[19929:5005565] 1---<NSThread: 0x600000264800>{number = 3, name = (null)}
2018-02-23 20:36:45.779286+0800 YSC-GCD-demo[19929:5005567] 3---<NSThread: 0x60000026f200>{number = 4, name = (null)}
2018-02-23 20:36:45.779302+0800 YSC-GCD-demo[19929:5005565] 1---<NSThread: 0x600000264800>{number = 3, name = (null)}
2018-02-23 20:36:45.779286+0800 YSC-GCD-demo[19929:5005566] 2---<NSThread: 0x604000266f00>{number = 5, name = (null)}

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

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

接下來再來講講串列隊列的兩種執行方式。

4.3 同步執行 + 串列隊列

  • 不會開啟新線程，在當前線程執行任務。任務是串列的，執行完一個任務，再執行下一個任務。
/**
 * 同步執行 + 串列隊列
 * 特點：不會開啟新線程，在當前線程執行任務。任務是串列的，執行完一個任務，再執行下一個任務。
 */
- (void)syncSerial {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 列印當前線程
    NSLog(@"syncSerial---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
    
    dispatch_sync(queue, ^{
        // 追加任務1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 列印當前線程
        }
    });
    dispatch_sync(queue, ^{
        // 追加任務2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 列印當前線程
        }
    });
    dispatch_sync(queue, ^{
        // 追加任務3
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 列印當前線程
        }
    });
    
    NSLog(@"syncSerial---end");
}

輸出結果為：
2018-02-23 20:39:37.876811+0800 YSC-GCD-demo[19975:5017162] currentThread---<NSThread: 0x604000079400>{number = 1, name = main}
2018-02-23 20:39:37.876998+0800 YSC-GCD-demo[19975:5017162] syncSerial---begin
2018-02-23 20:39:39.878316+0800 YSC-GCD-demo[19975:5017162] 1---<NSThread: 0x604000079400>{number = 1, name = main}
2018-02-23 20:39:41.879829+0800 YSC-GCD-demo[19975:5017162] 1---<NSThread: 0x604000079400>{number = 1, name = main}
2018-02-23 20:39:43.880660+0800 YSC-GCD-demo[19975:5017162] 2---<NSThread: 0x604000079400>{number = 1, name = main}
2018-02-23 20:39:45.881265+0800 YSC-GCD-demo[19975:5017162] 2---<NSThread: 0x604000079400>{number = 1, name = main}
2018-02-23 20:39:47.882257+0800 YSC-GCD-demo[19975:5017162] 3---<NSThread: 0x604000079400>{number = 1, name = main}
2018-02-23 20:39:49.883008+0800 YSC-GCD-demo[19975:5017162] 3---<NSThread: 0x604000079400>{number = 1, name = main}
2018-02-23 20:39:49.883253+0800 YSC-GCD-demo[19975:5017162] syncSerial---end

在同步執行 + 串列隊列可以看到：

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

4.4 非同步執行 + 串列隊列

  • 會開啟新線程，但是因為任務是串列的，執行完一個任務，再執行下一個任務
/**
 * 非同步執行 + 串列隊列
 * 特點：會開啟新線程，但是因為任務是串列的，執行完一個任務，再執行下一個任務。
 */
- (void)asyncSerial {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 列印當前線程
    NSLog(@"asyncSerial---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
    
    dispatch_async(queue, ^{
        // 追加任務1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 列印當前線程
        }
    });
    dispatch_async(queue, ^{
        // 追加任務2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 列印當前線程
        }
    });
    dispatch_async(queue, ^{
        // 追加任務3
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 列印當前線程
        }
    });
    
    NSLog(@"asyncSerial---end");
}

輸出結果為：
2018-02-23 20:41:17.029999+0800 YSC-GCD-demo[20008:5024757] currentThread---<NSThread: 0x604000070440>{number = 1, name = main}
2018-02-23 20:41:17.030212+0800 YSC-GCD-demo[20008:5024757] asyncSerial---begin
2018-02-23 20:41:17.030364+0800 YSC-GCD-demo[20008:5024757] asyncSerial---end
2018-02-23 20:41:19.035379+0800 YSC-GCD-demo[20008:5024950] 1---<NSThread: 0x60000026e100>{number = 3, name = (null)}
2018-02-23 20:41:21.037140+0800 YSC-GCD-demo[20008:5024950] 1---<NSThread: 0x60000026e100>{number = 3, name = (null)}
2018-02-23 20:41:23.042220+0800 YSC-GCD-demo[20008:5024950] 2---<NSThread: 0x60000026e100>{number = 3, name = (null)}
2018-02-23 20:41:25.042971+0800 YSC-GCD-demo[20008:5024950] 2---<NSThread: 0x60000026e100>{number = 3, name = (null)}
2018-02-23 20:41:27.047690+0800 YSC-GCD-demo[20008:5024950] 3---<NSThread: 0x60000026e100>{number = 3, name = (null)}
2018-02-23 20:41:29.052327+0800 YSC-GCD-demo[20008:5024950] 3---<NSThread: 0x60000026e100>{number = 3, name = (null)}

在非同步執行 + 串列隊列可以看到：

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

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

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

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

4.5 同步執行 + 主隊列

同步執行 + 主隊列在不同線程中調用結果也是不一樣，在主線程中調用會出現死鎖，而在其他線程中則不會。

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

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

輸出結果
2018-02-23 20:42:36.842892+0800 YSC-GCD-demo[20041:5030982] currentThread---<NSThread: 0x600000078a00>{number = 1, name = main}
2018-02-23 20:42:36.843050+0800 YSC-GCD-demo[20041:5030982] syncMain---begin
(lldb)

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

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

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

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

要是如果不在主線程中調用，而在其他線程中調用會如何呢？

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

  • 不會開啟新線程，執行完一個任務，再執行下一個任務
// 使用 NSThread 的 detachNewThreadSelector 方法會創建線程，並自動啟動線程執行
 selector 任務
[NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];

輸出結果：
2018-02-23 20:44:19.377321+0800 YSC-GCD-demo[20083:5040347] currentThread---<NSThread: 0x600000272fc0>{number = 3, name = (null)}
2018-02-23 20:44:19.377494+0800 YSC-GCD-demo[20083:5040347] syncMain---begin
2018-02-23 20:44:21.384716+0800 YSC-GCD-demo[20083:5040132] 1---<NSThread: 0x60000006c900>{number = 1, name = main}
2018-02-23 20:44:23.386091+0800 YSC-GCD-demo[20083:5040132] 1---<NSThread: 0x60000006c900>{number = 1, name = main}
2018-02-23 20:44:25.387687+0800 YSC-GCD-demo[20083:5040132] 2---<NSThread: 0x60000006c900>{number = 1, name = main}
2018-02-23 20:44:27.388648+0800 YSC-GCD-demo[20083:5040132] 2---<NSThread: 0x60000006c900>{number = 1, name = main}
2018-02-23 20:44:29.390459+0800 YSC-GCD-demo[20083:5040132] 3---<NSThread: 0x60000006c900>{number = 1, name = main}
2018-02-23 20:44:31.391965+0800 YSC-GCD-demo[20083:5040132] 3---<NSThread: 0x60000006c900>{number = 1, name = main}
2018-02-23 20:44:31.392513+0800 YSC-GCD-demo[20083:5040347] syncMain---end

在其他線程中使用同步執行 + 主隊列可看到：

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

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

4.6 非同步執行 + 主隊列

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

輸出結果：
2018-02-23 20:45:49.981505+0800 YSC-GCD-demo[20111:5046708] currentThread---<NSThread: 0x60000006d440>{number = 1, name = main}
2018-02-23 20:45:49.981935+0800 YSC-GCD-demo[20111:5046708] asyncMain---begin
2018-02-23 20:45:49.982352+0800 YSC-GCD-demo[20111:5046708] asyncMain---end
2018-02-23 20:45:51.991096+0800 YSC-GCD-demo[20111:5046708] 1---<NSThread: 0x60000006d440>{number = 1, name = main}
2018-02-23 20:45:53.991959+0800 YSC-GCD-demo[20111:5046708] 1---<NSThread: 0x60000006d440>{number = 1, name = main}
2018-02-23 20:45:55.992937+0800 YSC-GCD-demo[20111:5046708] 2---<NSThread: 0x60000006d440>{number = 1, name = main}
2018-02-23 20:45:57.993649+0800 YSC-GCD-demo[20111:5046708] 2---<NSThread: 0x60000006d440>{number = 1, name = main}
2018-02-23 20:45:59.994928+0800 YSC-GCD-demo[20111:5046708] 3---<NSThread: 0x60000006d440>{number = 1, name = main}
2018-02-23 20:46:01.995589+0800 YSC-GCD-demo[20111:5046708] 3---<NSThread: 0x60000006d440>{number = 1, name = main}

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

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

弄懂了難理解、繞來繞去的隊列+任務之後，我們來學習一個簡單的東西：5. GCD 線程間的通信。

5. GCD 線程間的通信

在iOS開發過程中，我們一般在主線程裡邊進行UI刷新，例如：點擊、滾動、拖拽等事件。我們通常把一些耗時的操作放在其他線程，比如說圖片下載、文件上傳等耗時操作。而當我們有時候在其他線程完成了耗時操作時，需要回到主線程，那麼就用到了線程之間的通訊。

/**
 * 線程間通信
 */
- (void)communication {
    // 獲取全局併發隊列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); 
    // 獲取主隊列
    dispatch_queue_t mainQueue = dispatch_get_main_queue(); 
    
    dispatch_async(queue, ^{
        // 非同步追加任務
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 列印當前線程
        }
        
        // 回到主線程
        dispatch_async(mainQueue, ^{
            // 追加在主線程中執行的任務
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 列印當前線程
        });
    });
}

輸出結果：
2018-02-23 20:47:03.462394+0800 YSC-GCD-demo[20154:5053282] 1---<NSThread: 0x600000271940>{number = 3, name = (null)}
2018-02-23 20:47:05.465912+0800 YSC-GCD-demo[20154:5053282] 1---<NSThread: 0x600000271940>{number = 3, name = (null)}
2018-02-23 20:47:07.466657+0800 YSC-GCD-demo[20154:5052953] 2---<NSThread: 0x60000007bf80>{number = 1, name = main}

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

6. GCD 的其他方法

6.1 GCD 柵欄方法：dispatch_barrier_async

  • 我們有時需要非同步執行兩組操作，而且第一組操作執行完之後，才能開始執行第二組操作。這樣我們就需要一個相當於柵欄一樣的一個方法將兩組非同步執行的操作組給分割起來，當然這裡的操作組裡可以包含一個或多個任務。這就需要用到dispatch_barrier_async方法在兩個操作組間形成柵欄。
    dispatch_barrier_async函數會等待前邊追加到併發隊列中的任務全部執行完畢之後，再將指定的任務追加到該非同步隊列中。然後在dispatch_barrier_async函數追加的任務執行完畢之後，非同步隊列才恢復為一般動作，接著追加任務到該非同步隊列並開始執行。具體如下圖所示：
      dispatch_barrier_async.png 
/**
 * 柵欄方法 dispatch_barrier_async
 */
- (void)barrier {
    dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(queue, ^{
        // 追加任務1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 列印當前線程
        }
    });
    dispatch_async(queue, ^{
        // 追加任務2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 列印當前線程
        }
    });
    
    dispatch_barrier_async(queue, ^{
        // 追加任務 barrier
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"barrier---%@",[NSThread currentThread]);// 列印當前線程
        }
    });
    
    dispatch_async(queue, ^{
        // 追加任務3
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 列印當前線程
        }
    });
    dispatch_async(queue, ^{
        // 追加任務4
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"4---%@",[NSThread currentThread]);      // 列印當前線程
        }
    });
}

輸出結果：
2018-02-23 20:48:18.297745+0800 YSC-GCD-demo[20188:5059274] 1---<NSThread: 0x600000079d80>{number = 4, name = (null)}
2018-02-23 20:48:18.297745+0800 YSC-GCD-demo[20188:5059273] 2---<NSThread: 0x600000079e00>{number = 3, name = (null)}
2018-02-23 20:48:20.301139+0800 YSC-GCD-demo[20188:5059274] 1---<NSThread: 0x600000079d80>{number = 4, name = (null)}
2018-02-23 20:48:20.301139+0800 YSC-GCD-demo[20188:5059273] 2---<NSThread: 0x600000079e00>{number = 3, name = (null)}
2018-02-23 20:48:22.306290+0800 YSC-GCD-demo[20188:5059274] barrier---<NSThread: 0x600000079d80>{number = 4, name = (null)}
2018-02-23 20:48:24.311655+0800 YSC-GCD-demo[20188:5059274] barrier---<NSThread: 0x600000079d80>{number = 4, name = (null)}
2018-02-23 20:48:26.316943+0800 YSC-GCD-demo[20188:5059273] 4---<NSThread: 0x600000079e00>{number = 3, name = (null)}
2018-02-23 20:48:26.316956+0800 YSC-GCD-demo[20188:5059274] 3---<NSThread: 0x600000079d80>{number = 4, name = (null)}
2018-02-23 20:48:28.320660+0800 YSC-GCD-demo[20188:5059273] 4---<NSThread: 0x600000079e00>{number = 3, name = (null)}
2018-02-23 20:48:28.320649+0800 YSC-GCD-demo[20188:5059274] 3---<NSThread: 0x600000079d80>{number = 4, name = (null)}

在dispatch_barrier_async執行結果中可以看出：

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

6.2 GCD 延時執行方法：dispatch_after

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

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

輸出結果：
2018-02-23 20:53:08.713784+0800 YSC-GCD-demo[20282:5080295] currentThread---<NSThread: 0x60000006ee00>{number = 1, name = main}
2018-02-23 20:53:08.713962+0800 YSC-GCD-demo[20282:5080295] asyncMain---begin
2018-02-23 20:53:10.714283+0800 YSC-GCD-demo[20282:5080295] after---<NSThread: 0x60000006ee00>{number = 1, name = main}

可以看出：在列印 asyncMain---begin之後大約 2.0 秒的時間，列印了 after---<NSThread: 0x60000006ee00>{number = 1, name = main}

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

  • 我們在創建單例、或者有整個程式運行過程中只執行一次的代碼時，我們就用到了 GCD 的 dispatch_once函數。使用
    dispatch_once函數能保證某段代碼在程式運行過程中只被執行1次，並且即使在多線程的環境下，dispatch_once也可以保證線程安全。
/**
 * 一次性代碼（只執行一次）dispatch_once
 */
- (void)once {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        // 只執行1次的代碼(這裡面預設是線程安全的)
    });
}

6.4 GCD 快速迭代方法：dispatch_apply

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

如果是在串列隊列中使用 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");
}

輸出結果：
2018-02-23 22:03:18.475499+0800 YSC-GCD-demo[20470:5176805] apply---begin
2018-02-23 22:03:18.476672+0800 YSC-GCD-demo[20470:5177035] 1---<NSThread: 0x60000027b8c0>{number = 3, name = (null)}
2018-02-23 22:03:18.476693+0800 YSC-GCD-demo[20470:5176805] 0---<NSThread: 0x604000070640>{number = 1, name = main}
2018-02-23 22:03:18.476704+0800 YSC-GCD-demo[20470:5177037] 2---<NSThread: 0x604000276800>{number = 4, name = (null)}
2018-02-23 22:03:18.476735+0800 YSC-GCD-demo[20470:5177036] 3---<NSThread: 0x60000027b800>{number = 5, name = (null)}
2018-02-23 22:03:18.476867+0800 YSC-GCD-demo[20470:5177035] 4---<NSThread: 0x60000027b8c0>{number = 3, name = (null)}
2018-02-23 22:03:18.476867+0800 YSC-GCD-demo[20470:5176805] 5---<NSThread: 0x604000070640>{number = 1, name = main}
2018-02-23 22:03:18.477038+0800 YSC-GCD-demo[20470:5176805] apply---end

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

6.5 GCD 隊列組：dispatch_group

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

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

6.5.1 dispatch_group_notify

  • 監聽 group 中任務的完成狀態，當所有的任務都執行完成後，追加任務到 group 中，並執行任務。
/**
 * 隊列組 dispatch_group_notify
 */
- (void)groupNotify {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 列印當前線程
    NSLog(@"group---begin");
    
    dispatch_group_t group =  dispatch_group_create();
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任務1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 列印當前線程
        }
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任務2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 列印當前線程
        }
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的非同步任務1、任務2都執行完畢後，回到主線程執行下邊任務
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模擬耗時操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 列印當前線程
        }
        NSLog(@"group---end");
    });
}
您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 高併發面試必問：分散式消息系統Kafka簡介
    轉載：https://blog.csdn.net/caisini_vc/article/details/48007297 Kafka是分散式發佈-訂閱消息系統。它最初由LinkedIn公司開發，之後成為Apache項目的一部分。Kafka是一個分散式的，可劃分的，冗餘備份的持久性的日誌服務。它主要用 ...
  • impdp導入表不創建segments
    一、文檔說明 二、操作記錄 --第一次導入操作failed --失敗原因，導入表創建語法DDL失敗，原因 1.導入環境為XE學習環境，資料庫容量最大11g，如果空間足夠，不會報錯 2.導入建表語法，dump文件小於200M，導入建表語句還未插入數據，已占用11G存儲，由於表的STORAGE(INIT ...
  • hive函數篇一
    hive 查看函數： show functions; desc functions 函數名 1. 時間函數 1.1 時間戳函數--日期轉時間戳：從1970-01-01 00:00:00 UTC到指定時間的秒數select unix_timestamp(); --獲得當前時區的UNIX時間戳selec ...
  • Hbase的安裝和基本使用
    Hbase介紹 HBase 是一個 "開源" 的 "非關係型" "分散式資料庫" （NoSQL），它參考了 "谷歌" 的 "BigTable" 建模，實現的編程語言為 "Java" 。它是 "Apache軟體基金會" 的 "Hadoop" 項目的一部分，運行於 "HDFS" 文件系統之上，為 "Ha ...
  • oracle資料庫字元集和客戶端字元集(2%)是不同的,字元集轉化可能會造成不可預期的後果
    linux架設oracle，用plsql連接資料庫時候報如下錯誤 ：“資料庫字元集和客戶端字元集(2%)是不同的,字元集轉化可能會造成不可預期的後果”，問題解決 ...
  • 學習iOS最權威的網站
    一、Apple 開發者網站 官方文檔 https://developer.apple.com/documentation 除了這兩個、還有 Core Foundation Core Animation Core Image 等、 趕快點擊網站去瞧瞧吧 https://developer.apple. ...
  • Android Activity生命周期圖解
    Android activity的生命周期這一張圖就夠了。 驗證結果： 值得註意的是從activity A >activity B是先執行A的onPause然後走B的生命周期最後才走A的onStop，同理從activity B按返回鍵時B進入onPause 然後走完A的生命周期在走B的onStop和 ...
  • 【OC底層】AssociatedObject 關聯對象
    如何實現給分類“添加成員變數”？ 預設情況下，因為分類底層結構的限制，不能添加成員變數到分類中。但可以通過關聯對象來間接實現 關聯對象提供了以下API 1> 添加關聯對象 void objc_setAssociatedObject(id object, const void * key, id va ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類