iOS 多執行緒之任務和佇列

阿新 • • 發佈：2020-10-23

前言

學習多執行緒，肯定要了解GCD,GCD兩個最核心的概念就是：任務和佇列。所以學習好多執行緒，首先要把任務和佇列吃透，才能能好的使用多執行緒。

為什麼使用GCD？

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

GCD 可用於多核的並行運算；
GCD 會自動利用更多的 CPU 核心（比如雙核、四核）；
GCD 會自動管理執行緒的生命週期（建立執行緒、排程任務、銷燬執行緒）；
程式設計師只需要告訴 GCD 想要執行什麼任務，不需要編寫任何執行緒管理程式碼。

任務

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

執行任務有兩種方式：

同步（sync）執行
- 同步新增任務到指定的佇列中，在新增的任務執行結束之前，會一直等待，直到佇列裡面的任務完成之後再繼續執行下一個任務。
- 只能在當前執行緒中執行任務，不具備開啟新執行緒的能力，所以會阻塞執行緒。
非同步（async）執行
- 非同步新增任務到指定的佇列中，它不會做任何等待，可以繼續執行任務。
- 可以在新的執行緒中執行任務，具備開啟新執行緒的能力，不會阻塞執行緒。

兩者的主要區別是：是否等待佇列的任務執行結束，以及是否具備開啟新執行緒的能力。

佇列

這裡的佇列指執行任務的等待佇列，即用來存放任務的佇列。

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

佇列.png

佇列有兩種：

序列佇列（Serial Dispatch Queue）
- 每次只有一個任務被執行。讓任務一個接著一個地執行。（只開啟一個執行緒，一個任務執行完畢後，再執行下一個任務）
並行佇列 (Concurrent Dispatch Queue）
- 可以讓多個任務併發（同時）執行。（可以開啟多個執行緒，並且同時執行任務）
  併發佇列.png

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

GCD使用步驟

GCD 的使用步驟其實很簡單隻有兩步：

首先建立一個佇列（序列佇列或併發佇列）；
最後將任務追加到任務的等待佇列中，然後系統就會根據任務型別執行任務（同步執行或非同步執行）

佇列使用

可以使用 dispatch_queue_create 方法來建立佇列。

第一個引數表示佇列的唯一識別符號，用於 DEBUG，可為空。佇列的名稱推薦使用應用程式 ID 這種逆序全程域名。
第二個引數用來識別是序列佇列還是併發佇列。DISPATCH_QUEUE_SERIAL 表示序列佇列，DISPATCH_QUEUE_CONCURRENT 表示併發佇列。

序列佇列建立

建立序列佇列

// 序列佇列的建立方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);

系統提供序列佇列-主佇列（Main Dispatch Queue）

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

所有放在主佇列中的任務，都會放到主執行緒中執行。
系統提供dispatch_get_main_queue() 方法獲得主佇列。

注意：主佇列其實並不特殊。主佇列的實質上就是一個普通的序列佇列，只是因為預設情況下，當前程式碼是放在主佇列中的，然後主佇列中的程式碼，有都會放到主執行緒中去執行，所以才造成了主佇列特殊的現象。

並行佇列建立

建立並行佇列

// 併發佇列的建立方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);

系統提供的-全域性併發佇列（Global Dispatch Queue
```
// 全域性併發佇列的獲取方法
```

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

```

可以使用 dispatch_get_global_queue 方法來獲取全域性併發佇列。
需要傳入兩個引數。第一個引數表示佇列優先順序，一般用 DISPATCH_QUEUE_PRIORITY_DEFAULT。第二個引數暫時沒用，用 0 即可。

建立任務方法

同步執行任務

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

非同步執行任務

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

任務和佇列的組合

既然我們有兩種佇列（序列佇列 / 併發佇列），兩種任務執行方式（同步執行 / 非同步執行），那麼我們就有了四種不同的組合方式。
這四種不同的組合方式是。

兩種預設佇列：全域性併發佇列、主佇列：

全域性併發佇列可以作為普通併發佇列來使用。
當前程式碼預設放在主佇列中，所以主佇列很有必要專門來研究一下，所以我們就又多了兩種組合方式。

這樣就有六種不同的組合方式了。（佇列好比一條路，（非同步可開啟多個執行緒）多執行緒好比多車道，並行好比能同時前進。）

同步執行 + 序列佇列（一條路，一車道，不可同時前進）
同步執行 + 並行佇列（一條路，一車道，不可同時前進）
非同步執行 + 序列佇列（一條路，多車道，不可同時前進）
非同步執行 + 並行佇列（一條路，多車道，可同時前進）
同步執行 + 主佇列（阻塞執行緒，卡死）
非同步執行 + 主佇列（和3.非同步執行 + 序列佇列一樣）

1.同步執行+序列佇列

- (void)syncSerial {

    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 列印當前執行緒
    NSLog(@"syncSerial---begin");
    //建立序列佇列
    dispatch_queue_t queue = dispatch_queue_create("testSerialQueue", 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");
}

執行列印結果：


輸出結果：
currentThread---<NSThread: 0x604000079400>{number = 1, name = main}
syncSerial---begin
1---<NSThread: 0x604000079400>{number = 1, name = main}
1---<NSThread: 0x604000079400>{number = 1, name = main}
2---<NSThread: 0x604000079400>{number = 1, name = main}
2---<NSThread: 0x604000079400>{number = 1, name = main}
3---<NSThread: 0x604000079400>{number = 1, name = main}
3---<NSThread: 0x604000079400>{number = 1, name = main}
syncSerial---end

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

2.同步執行+並行佇列

- (void)syncConcurrent {

    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 列印當前執行緒
    NSLog(@"syncConcurrent---begin");
    //建立並行佇列
    dispatch_queue_t queue = dispatch_queue_create("testConcurrentQueue", 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");
}

列印結果：

currentThread---<NSThread: 0x60400006bbc0>{number = 1, name = main}
syncConcurrent---begin
1---<NSThread: 0x60400006bbc0>{number = 1, name = main}
1---<NSThread: 0x60400006bbc0>{number = 1, name = main}
2---<NSThread: 0x60400006bbc0>{number = 1, name = main}
2---<NSThread: 0x60400006bbc0>{number = 1, name = main}
3---<NSThread: 0x60400006bbc0>{number = 1, name = main}
3---<NSThread: 0x60400006bbc0>{number = 1, name = main}
syncConcurrent---end

列印結果表明：
在當前執行緒中執行任務，不會開啟新執行緒，執行完一個任務，再執行下一個任務。

執行完同步+序列、同步+並行結果表明：

同步情況序列和並行執行結果一樣
同步不具有開啟新執行緒的能力
並行佇列雖然後並行執行任務的能力，但是在同步的情況下，沒有開啟新執行緒的能力，所以相當於序列執行(並行在同步的情況下，難免想起英雄無用武之地)。

3.非同步執行+序列佇列

- (void)asyncSerial {
    //列印當前執行緒
    NSLog(@"currentThread---%@",[NSThread currentThread]);   列印當前執行緒
    NSLog(@"asyncSerial---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("testSerialQueue", 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");
}

列印結果：

currentThread---<NSThread: 0x604000070440>{number = 1, name = main}
asyncSerial---begin
asyncSerial---end
1---<NSThread: 0x60000026e100>{number = 3, name = (null)}
1---<NSThread: 0x60000026e100>{number = 3, name = (null)}
2---<NSThread: 0x60000026e100>{number = 3, name = (null)}
2---<NSThread: 0x60000026e100>{number = 3, name = (null)}
3---<NSThread: 0x60000026e100>{number = 3, name = (null)}
3---<NSThread: 0x60000026e100>{number = 3, name = (null)}

直接結果表明：非同步情況下會開啟新執行緒，但是因為任務是序列的，執行完一個任務，再執行下一個任務。

4.非同步執行+並行佇列

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

執行列印結果：

currentThread---<NSThread: 0x604000062d80>{number = 1, name = main}
asyncConcurrent---begin
2---<NSThread: 0x604000266f00>{number = 5, name = (null)}
3---<NSThread: 0x60000026f200>{number = 4, name = (null)}
1---<NSThread: 0x600000264800>{number = 3, name = (null)}
3---<NSThread: 0x60000026f200>{number = 4, name = (null)}
1---<NSThread: 0x600000264800>{number = 3, name = (null)}
2---<NSThread: 0x604000266f00>{number = 5, name = (null)}

執行結果表明：可以開啟多個子執行緒，任務同時並行交替執行

在非同步執行任務的情況，序列佇列和並行隊列表明：

非同步情況下是開啟新執行緒
非同步下的序列也是是執行完一個任務，再執行下一個任務
非同步下的並行開啟多個子執行緒同時交替執行多個任務

4.同步執行+主佇列

- (void)syncMain {
   
   NSLog(@"currentThread---%@",[NSThread currentThread]);  // 列印當前執行緒
   NSLog(@"syncMain---begin");
   dispatch_queue_t syncMain = dispatch_get_main_queue();
   
   dispatch_sync(syncMain, ^{
       // 追加任務1
       for (int i = 0; i < 2; ++i) {
           [NSThread sleepForTimeInterval:2];             
           NSLog(@"1---%@",[NSThread currentThread]);     
       }
   });
   
   dispatch_sync(syncMain, ^{
       // 追加任務2
       for (int i = 0; i < 2; ++i) {
           [NSThread sleepForTimeInterval:2];             
           NSLog(@"2---%@",[NSThread currentThread]);      
       }
   });
   
   dispatch_sync(syncMain, ^{
       // 追加任務3
       for (int i = 0; i < 2; ++i) {
           [NSThread sleepForTimeInterval:2];              
           NSLog(@"3---%@",[NSThread currentThread]); 
       }
   });
   
   NSLog(@"syncMain---end");
}

執行結果：

currentThread---<NSThread: 0x600000078a00>{number = 1, name = main}
syncMain---begin

直接結果表明：互等卡主不執行，產生死鎖崩潰。

預設主執行緒在等待syncMain執行完任務1再往下執行，syncMain在等待預設主執行緒執行完再執行syncMain中任務1，所以互相等待產生死鎖。

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

執行列印結果：

currentThread---<NSThread: 0x60000006d440>{number = 1, name = main}
asyncMain---begin
asyncMain---end
1---<NSThread: 0x60000006d440>{number = 1, name = main}
1---<NSThread: 0x60000006d440>{number = 1, name = main}
2---<NSThread: 0x60000006d440>{number = 1, name = main}
2---<NSThread: 0x60000006d440>{number = 1, name = main}
3---<NSThread: 0x60000006d440>{number = 1, name = main}
3---<NSThread: 0x60000006d440>{number = 1, name = main}

因為主執行緒是序列佇列，所以在主執行緒中執行任務，執行完一個任務，再執行下一個任務。

總結

序列佇列的特點：
- 無論同步任務或是非同步任務，任務按順序執行，一個執行完畢執行下一個任務
- 序列佇列執行同步任務不開闢執行緒
- 執行非同步任務開闢最多開闢一條執行緒並且按順序執行
並行佇列的特點：
- 執行非同步任務具備開闢多條執行緒的能力
- 執行同步任務，順序執行，因為同步不具有開闢執行緒的能力
同步任務特點：
- 沒有開啟新執行緒的能力
- 在當前執行緒任務按順序一個一個執行
非同步任務的特點：
- 具有開啟新執行緒的能力
- 開幾條新執行緒取決於佇列，序列佇列開啟一條執行緒，並行佇列在執行多個非同步任務時會開闢多條執行緒。

iOS 多執行緒之任務和佇列

前言學習多執行緒，肯定要了解GCD,GCD兩個最核心的概念就是：任務和佇列。所以學習好多執行緒，首先要把任務和佇列吃透，才能能好的使用多執行緒。

iOS多執行緒之GCD、OperationQueue 對比和實踐記錄

目錄簡介GCD、OperationQueue 對比核心理念區別GCD佇列序列佇列（Serial Queues）併發佇列（Concurrent Queues）序列、併發佇列對比圖注意事項block（塊）相關dispatch_afterdispatch_semaphoredispatch_apply自問自