iOS多線程全套：線程生命週期，多線程的四種解決方案，線程安全問題，GCD的使用，NSOperation的使用

時間 2019-11-16

標籤 ios 多線程全套線程生命週期四種解決方案安全問題 gcd 使用 nsoperation 欄目 iOS 简体版

原文原文鏈接

目的

本文主要是分享iOS多線程的相關內容，爲了更系統的講解，將分爲如下7個方面來展開描述。git

多線程的基本概念

線程的狀態與生命週期

多線程的四種解決方案：pthread，NSThread，GCD，NSOperation

線程安全問題

NSThread的使用

GCD的理解與使用

NSOperation的理解與使用

Demo 在這裏：WHMultiThreadDemo Demo的運行gif圖以下：程序員

1、多線程的基本概念

進程：能夠理解成一個運行中的應用程序，是系統進行資源分配和調度的基本單位，是操做系統結構的基礎，主要管理資源。github

線程：是進程的基本執行單元，一個進程對應多個線程。安全

主線程：處理UI，全部更新UI的操做都必須在主線程上執行。不要把耗時操做放在主線程，會卡界面。多線程

多線程：在同一時刻，一個CPU只能處理1條線程，但CPU能夠在多條線程之間快速的切換，只要切換的足夠快，就形成了多線程一同執行的假象。併發

線程就像火車的一節車箱，進程則是火車。車箱（線程）離開火車（進程）是沒法跑動的，而火車（進程）至少有一節車箱（主線程）。多線程能夠看作多個車箱，它的出現是爲了提升效率。多線程是經過提升資源使用率來提升系統整體的效率。app

咱們運用多線程的目的是：將耗時的操做放在後臺執行！異步

2、線程的狀態與生命週期

線程的生命週期是：新建 - 就緒 - 運行 - 阻塞 - 死亡async

下面分別闡述線程生命週期中的每一步函數

新建：實例化線程對象

就緒：向線程對象發送start消息，線程對象被加入可調度線程池等待CPU調度。

運行：CPU 負責調度可調度線程池中線程的執行。線程執行完成以前，狀態可能會在就緒和運行之間來回切換。就緒和運行之間的狀態變化由CPU負責，程序員不能干預。

阻塞：當知足某個預約條件時，可使用休眠或鎖，阻塞線程執行。sleepForTimeInterval（休眠指定時長），sleepUntilDate（休眠到指定日期），@synchronized(self)：（互斥鎖）。

死亡：正常死亡，線程執行完畢。非正常死亡，當知足某個條件後，在線程內部停止執行/在主線程停止線程對象

還有線程的exit和cancel [NSThread exit]：一旦強行終止線程，後續的全部代碼都不會被執行。 [thread cancel]取消：並不會直接取消線程，只是給線程對象添加 isCancelled 標記。

3、多線程的四種解決方案

多線程的四種解決方案分別是：pthread，NSThread，GCD， NSOperation。

pthread：運用C語言，是一套通用的API，可跨平臺Unix/Linux/Windows。線程的生命週期由程序員管理。 NSThread：面向對象，可直接操做線程對象。線程的生命週期由程序員管理。 GCD：代替NSThread，能夠充分利用設備的多核，自動管理線程生命週期。 NSOperation：底層是GCD，比GCD多了一些方法，更加面向對象，自動管理線程生命週期。

4、線程安全問題

當多個線程訪問同一塊資源時，很容易引起數據錯亂和數據安全問題。就比如幾我的在同一時修改同一個表格，形成數據的錯亂。

解決多線程安全問題的方法

方法一：互斥鎖（同步鎖）

@synchronized(鎖對象) {
    // 須要鎖定的代碼
}
複製代碼

判斷的時候鎖對象要存在，若是代碼中只有一個地方須要加鎖，大多都使用self做爲鎖對象，這樣能夠避免單獨再建立一個鎖對象。加了互斥作的代碼，當新線程訪問時，若是發現其餘線程正在執行鎖定的代碼，新線程就會進入休眠。

方法二：自旋鎖加了自旋鎖，當新線程訪問代碼時，若是發現有其餘線程正在鎖定代碼，新線程會用死循環的方式，一直等待鎖定的代碼執行完成。至關於不停嘗試執行代碼，比較消耗性能。屬性修飾atomic自己就有一把自旋鎖。

下面說一下屬性修飾nonatomic 和 atomic

nonatomic 非原子屬性,同一時間能夠有不少線程讀和寫
atomic 原子屬性(線程安全)，保證同一時間只有一個線程可以寫入(可是同一個時間多個線程均可以取值)，atomic 自己就有一把鎖(自旋鎖)

atomic：線程安全，須要消耗大量的資源
nonatomic：非線程安全，不過效率更高，通常使用nonatomic
複製代碼

5、NSThread的使用

No.1：NSThread建立線程

NSThread有三種建立方式：

init方式
detachNewThreadSelector建立好以後自動啓動
performSelectorInBackground建立好以後也是直接啓動

/** 方法一，須要start */
NSThread *thread1 = [[NSThread alloc] initWithTarget:self selector:@selector(doSomething1:) object:@"NSThread1"];
// 線程加入線程池等待CPU調度，時間很快，幾乎是馬上執行
[thread1 start];
    
/** 方法二，建立好以後自動啓動 */
[NSThread detachNewThreadSelector:@selector(doSomething2:) toTarget:self withObject:@"NSThread2"];
    
/** 方法三，隱式建立，直接啓動 */
[self performSelectorInBackground:@selector(doSomething3:) withObject:@"NSThread3"];

- (void)doSomething1:(NSObject *)object {
    // 傳遞過來的參數
    NSLog(@"%@",object);
    NSLog(@"doSomething1：%@",[NSThread currentThread]);
}

- (void)doSomething2:(NSObject *)object {
    NSLog(@"%@",object);
    NSLog(@"doSomething2：%@",[NSThread currentThread]);
}

- (void)doSomething3:(NSObject *)object {
    NSLog(@"%@",object);
    NSLog(@"doSomething3：%@",[NSThread currentThread]);
}
複製代碼

No.2：NSThread的類方法

返回當前線程

// 當前線程
[NSThread currentThread];
NSLog(@"%@",[NSThread currentThread]);

// 若是number=1，則表示在主線程，不然是子線程
打印結果：<NSThread: 0x608000261380>{number = 1, name = main}
複製代碼

阻塞休眠

//休眠多久
[NSThread sleepForTimeInterval:2];
//休眠到指定時間
[NSThread sleepUntilDate:[NSDate date]];
複製代碼

類方法補充

//退出線程
[NSThread exit];
//判斷當前線程是否爲主線程
[NSThread isMainThread];
//判斷當前線程是不是多線程
[NSThread isMultiThreaded];
//主線程的對象
NSThread *mainThread = [NSThread mainThread];
複製代碼

No.3：NSThread的一些屬性

//線程是否在執行
thread.isExecuting;
//線程是否被取消
thread.isCancelled;
//線程是否完成
thread.isFinished;
//是不是主線程
thread.isMainThread;
//線程的優先級，取值範圍0.0到1.0，默認優先級0.5，1.0表示最高優先級，優先級高，CPU調度的頻率高
 thread.threadPriority;
複製代碼

Demo：WHMultiThreadDemo

6、GCD的理解與使用

No.1：GCD的特色

GCD會自動利用更多的CPU內核

GCD自動管理線程的生命週期（建立線程，調度任務，銷燬線程等）

程序員只須要告訴 GCD 想要如何執行什麼任務，不須要編寫任何線程管理代碼

No.2：GCD的基本概念

任務（block）：任務就是將要在線程中執行的代碼，將這段代碼用block封裝好，而後將這個任務添加到指定的執行方式（同步執行和異步執行），等待CPU從隊列中取出任務放到對應的線程中執行。

同步（sync）：一個接着一個，前一個沒有執行完，後面不能執行，不開線程。

異步（async）：開啓多個新線程，任務同一時間能夠一塊兒執行。異步是多線程的代名詞

隊列：裝載線程任務的隊形結構。(系統以先進先出的方式調度隊列中的任務執行)。在GCD中有兩種隊列：串行隊列和併發隊列。

併發隊列：線程能夠同時一塊兒進行執行。其實是CPU在多條線程之間快速的切換。（併發功能只有在異步（dispatch_async）函數下才有效）

串行隊列：線程只能依次有序的執行。

GCD總結：將任務(要在線程中執行的操做block)添加到隊列(本身建立或使用全局併發隊列)，而且指定執行任務的方式(異步dispatch_async，同步dispatch_sync)

No.3：隊列的建立方法

使用dispatch_queue_create來建立隊列對象，傳入兩個參數，第一個參數表示隊列的惟一標識符，可爲空。第二個參數用來表示串行隊列（DISPATCH_QUEUE_SERIAL）或併發隊列（DISPATCH_QUEUE_CONCURRENT）。

// 串行隊列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
// 併發隊列
dispatch_queue_t queue1 = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
複製代碼

GCD的隊列還有另外兩種：

主隊列：主隊列負責在主線程上調度任務，若是在主線程上已經有任務正在執行，主隊列會等到主線程空閒後再調度任務。一般是返回主線程更新UI的時候使用。dispatch_get_main_queue()

dispatch_async(dispatch_get_global_queue(0, 0), ^{
        // 耗時操做放在這裏
        
        dispatch_async(dispatch_get_main_queue(), ^{
            // 回到主線程進行UI操做
            
        });
    });
複製代碼

全局併發隊列：全局併發隊列是就是一個併發隊列，是爲了讓咱們更方便的使用多線程。dispatch_get_global_queue(0, 0)

//全局併發隊列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//全局併發隊列的優先級
#define DISPATCH_QUEUE_PRIORITY_HIGH 2 // 高優先級
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 // 默認（中）優先級
#define DISPATCH_QUEUE_PRIORITY_LOW (-2) // 低優先級
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 後臺優先級
//iOS8開始使用服務質量，如今獲取全局併發隊列時，能夠直接傳0
dispatch_get_global_queue(0, 0);
複製代碼

No.4：同步/異步/任務、建立方式

同步（sync）使用dispatch_sync來表示。異步（async）使用dispatch_async。任務就是將要在線程中執行的代碼，將這段代碼用block封裝好。代碼以下：

// 同步執行任務
    dispatch_sync(dispatch_get_global_queue(0, 0), ^{
        // 任務放在這個block裏
        NSLog(@"我是同步執行的任務");

    });
    // 異步執行任務
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        // 任務放在這個block裏
        NSLog(@"我是異步執行的任務");

    });
複製代碼

Demo：WHMultiThreadDemo

No.5：GCD的使用

因爲有多種隊列（串行/併發/主隊列）和兩種執行方式（同步/異步），因此他們之間能夠有多種組合方式。

串行同步串行異步併發同步併發異步主隊列同步主隊列異步

串行同步執行完一個任務，再執行下一個任務。不開啓新線程。

/** 串行同步 */
- (void)syncSerial {
    
    NSLog(@"\n\n**************串行同步***************\n\n");
    
    // 串行隊列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
    
    // 同步執行
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行同步1 %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行同步2 %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行同步3 %@",[NSThread currentThread]);
        }
    });
}
複製代碼

輸入結果爲順序執行，都在主線程：

串行同步1   <NSThread: 0x60000007c500>{number = 1, name = main}
串行同步1   <NSThread: 0x60000007c500>{number = 1, name = main}
串行同步1   <NSThread: 0x60000007c500>{number = 1, name = main}
串行同步2   <NSThread: 0x60000007c500>{number = 1, name = main}
串行同步2   <NSThread: 0x60000007c500>{number = 1, name = main}
串行同步2   <NSThread: 0x60000007c500>{number = 1, name = main}
串行同步3   <NSThread: 0x60000007c500>{number = 1, name = main}
串行同步3   <NSThread: 0x60000007c500>{number = 1, name = main}
串行同步3   <NSThread: 0x60000007c500>{number = 1, name = main}
複製代碼

串行異步開啓新線程，但由於任務是串行的，因此仍是按順序執行任務。

/** 串行異步 */
- (void)asyncSerial {
    
    NSLog(@"\n\n**************串行異步***************\n\n");
    
    // 串行隊列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
    
    // 同步執行
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行異步1 %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行異步2 %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行異步3 %@",[NSThread currentThread]);
        }
    });
}
複製代碼

輸入結果爲順序執行，有不一樣線程：

串行異步1   <NSThread: 0x60000026d740>{number = 3, name = (null)}
串行異步1   <NSThread: 0x60000026d740>{number = 3, name = (null)}
串行異步1   <NSThread: 0x60000026d740>{number = 3, name = (null)}
串行異步2   <NSThread: 0x60000026d740>{number = 3, name = (null)}
串行異步2   <NSThread: 0x60000026d740>{number = 3, name = (null)}
串行異步2   <NSThread: 0x60000026d740>{number = 3, name = (null)}
串行異步3   <NSThread: 0x60000026d740>{number = 3, name = (null)}
串行異步3   <NSThread: 0x60000026d740>{number = 3, name = (null)}
串行異步3   <NSThread: 0x60000026d740>{number = 3, name = (null)}
複製代碼

併發同步由於是同步的，因此執行完一個任務，再執行下一個任務。不會開啓新線程。

/** 併發同步 */
- (void)syncConcurrent {
    
    NSLog(@"\n\n**************併發同步***************\n\n");
    
    // 併發隊列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    
    // 同步執行
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"併發同步1 %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"併發同步2 %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"併發同步3 %@",[NSThread currentThread]);
        }
    });
}
複製代碼

輸入結果爲順序執行，都在主線程：

併發同步1   <NSThread: 0x60000007c500>{number = 1, name = main}
併發同步1   <NSThread: 0x60000007c500>{number = 1, name = main}
併發同步1   <NSThread: 0x60000007c500>{number = 1, name = main}
併發同步2   <NSThread: 0x60000007c500>{number = 1, name = main}
併發同步2   <NSThread: 0x60000007c500>{number = 1, name = main}
併發同步2   <NSThread: 0x60000007c500>{number = 1, name = main}
併發同步3   <NSThread: 0x60000007c500>{number = 1, name = main}
併發同步3   <NSThread: 0x60000007c500>{number = 1, name = main}
併發同步3   <NSThread: 0x60000007c500>{number = 1, name = main}
複製代碼

併發異步任務交替執行，開啓多線程。

/** 併發異步 */
- (void)asyncConcurrent {
    
    NSLog(@"\n\n**************併發異步***************\n\n");
    
    // 併發隊列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    
    // 同步執行
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"併發異步1 %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"併發異步2 %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"併發異步3 %@",[NSThread currentThread]);
        }
    });
}
複製代碼

輸入結果爲無序執行，有多條線程：

併發異步1   <NSThread: 0x60000026d740>{number = 3, name = (null)}
併發異步2   <NSThread: 0x60000026dc80>{number = 4, name = (null)}
併發異步3   <NSThread: 0x60800026ab40>{number = 5, name = (null)}
併發異步1   <NSThread: 0x60000026d740>{number = 3, name = (null)}
併發異步2   <NSThread: 0x60000026dc80>{number = 4, name = (null)}
併發異步3   <NSThread: 0x60800026ab40>{number = 5, name = (null)}
併發異步1   <NSThread: 0x60000026d740>{number = 3, name = (null)}
併發異步2   <NSThread: 0x60000026dc80>{number = 4, name = (null)}
併發異步3   <NSThread: 0x60800026ab40>{number = 5, name = (null)}
複製代碼

主隊列同步若是在主線程中運用這種方式，則會發生死鎖，程序崩潰。

/** 主隊列同步 */
- (void)syncMain {
    
    NSLog(@"\n\n**************主隊列同步，放到主線程會死鎖***************\n\n");
    
    // 主隊列
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主隊列同步1 %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主隊列同步2 %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主隊列同步3 %@",[NSThread currentThread]);
        }
    });
}
複製代碼

主隊列同步形成死鎖的緣由：若是在主線程中運用主隊列同步，也就是把任務放到了主線程的隊列中。而同步對於任務是馬上執行的，那麼當把第一個任務放進主隊列時，它就會立馬執行。但是主線程如今正在處理syncMain方法，任務須要等syncMain執行完才能執行。 syncMain執行到第一個任務的時候，又要等第一個任務執行完才能往下執行第二個和第三個任務。這樣syncMain方法和第一個任務就開始了互相等待，造成了死鎖。

主隊列異步在主線程中任務按順序執行。

/** 主隊列異步 */
- (void)asyncMain {
    
    NSLog(@"\n\n**************主隊列異步***************\n\n");
    
    // 主隊列
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主隊列異步1 %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主隊列異步2 %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主隊列異步3 %@",[NSThread currentThread]);
        }
    });
}
複製代碼

輸入結果爲在主線程中按順序執行：

主隊列異步1   <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步1   <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步1   <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步2   <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步2   <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步2   <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步3   <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步3   <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步3   <NSThread: 0x60000007c500>{number = 1, name = main}
複製代碼

GCD線程之間的通信開發中須要在主線程上進行UI的相關操做，一般會把一些耗時的操做放在其餘線程，好比說圖片文件下載等耗時操做。當完成了耗時操做以後，須要回到主線程進行UI的處理，這裏就用到了線程之間的通信。

- (IBAction)communicationBetweenThread:(id)sender {
    
    // 異步
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        // 耗時操做放在這裏，例以下載圖片。（運用線程休眠兩秒來模擬耗時操做）
        [NSThread sleepForTimeInterval:2];
        NSString *picURLStr = @"http://www.bangmangxuan.net/uploads/allimg/160320/74-160320130500.jpg";
        NSURL *picURL = [NSURL URLWithString:picURLStr];
        NSData *picData = [NSData dataWithContentsOfURL:picURL];
        UIImage *image = [UIImage imageWithData:picData];
        
        // 回到主線程處理UI
        dispatch_async(dispatch_get_main_queue(), ^{
            // 在主線程上添加圖片
            self.imageView.image = image;
        });
    });
}
複製代碼

上面的代碼是在新開的線程中進行圖片的下載，下載完成以後回到主線程顯示圖片。

GCD柵欄當任務須要異步進行，可是這些任務須要分紅兩組來執行，第一組完成以後才能進行第二組的操做。這時候就用了到GCD的柵欄方法dispatch_barrier_async。

- (IBAction)barrierGCD:(id)sender {
    
    // 併發隊列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    
    // 異步執行
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"柵欄：併發異步1 %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"柵欄：併發異步2 %@",[NSThread currentThread]);
        }
    });
    
    dispatch_barrier_async(queue, ^{
        NSLog(@"------------barrier------------%@", [NSThread currentThread]);
        NSLog(@"******* 併發異步執行，可是34必定在12後面 *********");
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"柵欄：併發異步3 %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"柵欄：併發異步4 %@",[NSThread currentThread]);
        }
    });
}
複製代碼

上面代碼的打印結果以下，開啓了多條線程，全部任務都是併發異步進行。可是第一組完成以後，纔會進行第二組的操做。

柵欄：併發異步1   <NSThread: 0x60000026d740>{number = 3, name = (null)}
柵欄：併發異步2   <NSThread: 0x60000026e480>{number = 6, name = (null)}
柵欄：併發異步1   <NSThread: 0x60000026d740>{number = 3, name = (null)}
柵欄：併發異步2   <NSThread: 0x60000026e480>{number = 6, name = (null)}
柵欄：併發異步1   <NSThread: 0x60000026d740>{number = 3, name = (null)}
柵欄：併發異步2   <NSThread: 0x60000026e480>{number = 6, name = (null)}
 ------------barrier------------<NSThread: 0x60000026e480>{number = 6, name = (null)}
******* 併發異步執行，可是34必定在12後面 *********
柵欄：併發異步4   <NSThread: 0x60000026d740>{number = 3, name = (null)}
柵欄：併發異步3   <NSThread: 0x60000026e480>{number = 6, name = (null)}
柵欄：併發異步4   <NSThread: 0x60000026d740>{number = 3, name = (null)}
柵欄：併發異步3   <NSThread: 0x60000026e480>{number = 6, name = (null)}
柵欄：併發異步4   <NSThread: 0x60000026d740>{number = 3, name = (null)}
柵欄：併發異步3   <NSThread: 0x60000026e480>{number = 6, name = (null)}
複製代碼

GCD延時執行當須要等待一會再執行一段代碼時，就能夠用到這個方法了：dispatch_after。

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    // 5秒後異步執行
    NSLog(@"我已經等待了5秒！");
});
複製代碼

GCD實現代碼只執行一次使用dispatch_once能保證某段代碼在程序運行過程當中只被執行1次。能夠用來設計單例。

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    NSLog(@"程序運行過程當中我只執行了一次！");
});
複製代碼

GCD快速迭代 GCD有一個快速迭代的方法dispatch_apply，dispatch_apply能夠同時遍歷多個數字。

- (IBAction)applyGCD:(id)sender {
    
    NSLog(@"\n\n************** GCD快速迭代 ***************\n\n");
    
    // 併發隊列
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    
    // dispatch_apply幾乎同時遍歷多個數字
    dispatch_apply(7, queue, ^(size_t index) {
        NSLog(@"dispatch_apply：%zd======%@",index, [NSThread currentThread]);
    });
}
複製代碼

打印結果以下：

dispatch_apply：0======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：1======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：2======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：3======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：4======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：5======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：6======<NSThread: 0x60000007c500>{number = 1, name = main}
複製代碼

GCD隊列組異步執行幾個耗時操做，當這幾個操做都完成以後再回到主線程進行操做，就能夠用到隊列組了。隊列組有下面幾個特色：

全部的任務會併發的執行(不按序)。全部的異步函數都添加到隊列中，而後再歸入隊列組的監聽範圍。使用dispatch_group_notify函數，來監聽上面的任務是否完成，若是完成, 就會調用這個方法。

隊列組示例代碼：

- (void)testGroup {
    dispatch_group_t group =  dispatch_group_create();
    
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        NSLog(@"隊列組：有一個耗時操做完成！");
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        NSLog(@"隊列組：有一個耗時操做完成！");
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"隊列組：前面的耗時操做都完成了，回到主線程進行相關操做");
    });
}
複製代碼

打印結果以下：

隊列組：有一個耗時操做完成！
隊列組：有一個耗時操做完成！
隊列組：前面的耗時操做都完成了，回到主線程進行相關操做
複製代碼

至此，GCD的相關內容敘述完畢。下面讓咱們繼續學習NSOperation。

Demo：WHMultiThreadDemo

7、NSOperation的理解與使用

No.1：NSOperation簡介

NSOperation是基於GCD之上的更高一層封裝，NSOperation須要配合NSOperationQueue來實現多線程。

NSOperation實現多線程的步驟以下：

1. 建立任務：先將須要執行的操做封裝到NSOperation對象中。
2. 建立隊列：建立NSOperationQueue。
3. 將任務加入到隊列中：將NSOperation對象添加到NSOperationQueue中。
複製代碼

須要注意的是，NSOperation是個抽象類，實際運用時中須要使用它的子類，有三種方式：

使用子類NSInvocationOperation

使用子類NSBlockOperation

定義繼承自NSOperation的子類，經過實現內部相應的方法來封裝任務。

No.2：NSOperation的三種建立方式

NSInvocationOperation的使用建立NSInvocationOperation對象並關聯方法，以後start。

- (void)testNSInvocationOperation {
    // 建立NSInvocationOperation
    NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperation) object:nil];
    // 開始執行操做
    [invocationOperation start];
}

- (void)invocationOperation {
    NSLog(@"NSInvocationOperation包含的任務，沒有加入隊列========%@", [NSThread currentThread]);
}
複製代碼

打印結果以下，獲得結論：程序在主線程執行，沒有開啓新線程。這是由於NSOperation多線程的使用須要配合隊列NSOperationQueue，後面會講到NSOperationQueue的使用。

NSInvocationOperation包含的任務，沒有加入隊列========<NSThread: 0x6000000783c0>{number = 1, name = main}
複製代碼

NSBlockOperation的使用把任務放到NSBlockOperation的block中，而後start。

- (void)testNSBlockOperation {
    // 把任務放到block中
    NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"NSBlockOperation包含的任務，沒有加入隊列========%@", [NSThread currentThread]);
    }];
    
    [blockOperation start];
}
複製代碼

執行結果以下，能夠看出：主線程執行，沒有開啓新線程。一樣的，NSBlockOperation能夠配合隊列NSOperationQueue來實現多線程。

NSBlockOperation包含的任務，沒有加入隊列========<NSThread: 0x6000000783c0>{number = 1, name = main}
複製代碼

可是NSBlockOperation有一個方法addExecutionBlock:，經過這個方法可讓NSBlockOperation實現多線程。

- (void)testNSBlockOperationExecution {
    NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"NSBlockOperation運用addExecutionBlock主任務========%@", [NSThread currentThread]);
    }];
    
    [blockOperation addExecutionBlock:^{
        NSLog(@"NSBlockOperation運用addExecutionBlock方法添加任務1========%@", [NSThread currentThread]);
    }];
    [blockOperation addExecutionBlock:^{
        NSLog(@"NSBlockOperation運用addExecutionBlock方法添加任務2========%@", [NSThread currentThread]);
    }];
    [blockOperation addExecutionBlock:^{
        NSLog(@"NSBlockOperation運用addExecutionBlock方法添加任務3========%@", [NSThread currentThread]);
    }];
    
    [blockOperation start];
}
複製代碼

執行結果以下，能夠看出，NSBlockOperation建立時block中的任務是在主線程執行，而運用addExecutionBlock加入的任務是在子線程執行的。

NSBlockOperation運用addExecutionBlock========<NSThread: 0x60800006ccc0>{number = 1, name = main}
addExecutionBlock方法添加任務1========<NSThread: 0x60800007ec00>{number = 3, name = (null)}
addExecutionBlock方法添加任務3========<NSThread: 0x6000002636c0>{number = 5, name = (null)}
addExecutionBlock方法添加任務2========<NSThread: 0x60800007e800>{number = 4, name = (null)}
複製代碼

運用繼承自NSOperation的子類首先咱們定義一個繼承自NSOperation的類，而後重寫它的main方法，以後就可使用這個子類來進行相關的操做了。

/*******************"WHOperation.h"*************************/

#import <Foundation/Foundation.h>

@interface WHOperation : NSOperation

@end


/*******************"WHOperation.m"*************************/

#import "WHOperation.h"

@implementation WHOperation

- (void)main {
    for (int i = 0; i < 3; i++) {
        NSLog(@"NSOperation的子類WHOperation======%@",[NSThread currentThread]);
    }
}

@end


/*****************回到主控制器使用WHOperation**********************/

- (void)testWHOperation {
    WHOperation *operation = [[WHOperation alloc] init];
    [operation start];
}
複製代碼

運行結果以下，依然是在主線程執行。

SOperation的子類WHOperation======<NSThread: 0x608000066780>{number = 1, name = main}
NSOperation的子類WHOperation======<NSThread: 0x608000066780>{number = 1, name = main}
NSOperation的子類WHOperation======<NSThread: 0x608000066780>{number = 1, name = main}
複製代碼

因此，NSOperation是須要配合隊列NSOperationQueue來實現多線程的。下面就來講一下隊列NSOperationQueue。

No.3：隊列NSOperationQueue

NSOperationQueue只有兩種隊列：主隊列、其餘隊列。其餘隊列包含了串行和併發。

主隊列的建立以下，主隊列上的任務是在主線程執行的。

NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];
複製代碼

其餘隊列（非主隊列）的建立以下，加入到‘非隊列’中的任務默認就是併發，開啓多線程。

NSOperationQueue *queue = [[NSOperationQueue alloc] init];
複製代碼

注意：

非主隊列（其餘隊列）能夠實現串行或並行。
隊列NSOperationQueue有一個參數叫作最大併發數：maxConcurrentOperationCount。
maxConcurrentOperationCount默認爲-1，直接併發執行，因此加入到‘非隊列’中的任務默認就是併發，開啓多線程。
當maxConcurrentOperationCount爲1時，則表示不開線程，也就是串行。
當maxConcurrentOperationCount大於1時，進行併發執行。
系統對最大併發數有一個限制，因此即便程序員把maxConcurrentOperationCount設置的很大，系統也會自動調整。因此把最大併發數設置的很大是沒有意義的。

No.4：NSOperation + NSOperationQueue

把任務加入隊列，這纔是NSOperation的常規使用方式。

addOperation添加任務到隊列

先建立好任務，而後運用- (void)addOperation:(NSOperation *)op 方法來吧任務添加到隊列中，示例代碼以下：

- (void)testOperationQueue {
    // 建立隊列，默認併發
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    // 建立操做，NSInvocationOperation
    NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperationAddOperation) object:nil];
    // 建立操做，NSBlockOperation
    NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"addOperation把任務添加到隊列======%@", [NSThread currentThread]);
        }
    }];
    
    [queue addOperation:invocationOperation];
    [queue addOperation:blockOperation];
}


- (void)invocationOperationAddOperation {
    NSLog(@"invocationOperation===aaddOperation把任務添加到隊列====%@", [NSThread currentThread]);
}
複製代碼

運行結果以下，能夠看出，任務都是在子線程執行的，開啓了新線程！

invocationOperation===addOperation把任務添加到隊列====<NSThread: 0x60800026ed00>{number = 4, name = (null)}
addOperation把任務添加到隊列======<NSThread: 0x60800026e640>{number = 3, name = (null)}
addOperation把任務添加到隊列======<NSThread: 0x60800026e640>{number = 3, name = (null)}
addOperation把任務添加到隊列======<NSThread: 0x60800026e640>{number = 3, name = (null)}
複製代碼

addOperationWithBlock添加任務到隊列

這是一個更方便的把任務添加到隊列的方法，直接把任務寫在block中，添加到任務中。

- (void)testAddOperationWithBlock {
    // 建立隊列，默認併發
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    // 添加操做到隊列
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"addOperationWithBlock把任務添加到隊列======%@", [NSThread currentThread]);
        }
    }];
}
複製代碼

運行結果以下，任務確實是在子線程中執行。

addOperationWithBlock把任務添加到隊列======<NSThread: 0x6000000752c0>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列======<NSThread: 0x6000000752c0>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列======<NSThread: 0x6000000752c0>{number = 3, name = (null)}
複製代碼

運用最大併發數實現串行上面已經說過，能夠運用隊列的屬性maxConcurrentOperationCount（最大併發數）來實現串行，值須要把它設置爲1就能夠了，下面咱們經過代碼驗證一下。

- (void)testMaxConcurrentOperationCount {
    // 建立隊列，默認併發
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    // 最大併發數爲1，串行
    queue.maxConcurrentOperationCount = 1;
    
    // 最大併發數爲2，併發
// queue.maxConcurrentOperationCount = 2;
    
    
    // 添加操做到隊列
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"addOperationWithBlock把任務添加到隊列1======%@", [NSThread currentThread]);
        }
    }];
    
    // 添加操做到隊列
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"addOperationWithBlock把任務添加到隊列2======%@", [NSThread currentThread]);
        }
    }];
    
    // 添加操做到隊列
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"addOperationWithBlock把任務添加到隊列3======%@", [NSThread currentThread]);
        }
    }];
}
複製代碼

運行結果以下，當最大併發數爲1的時候，雖然開啓了線程，可是任務是順序執行的，因此實現了串行。你能夠嘗試把上面的最大併發數變爲2，會發現任務就變成了併發執行。

addOperationWithBlock把任務添加到隊列1======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列1======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列1======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列2======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列2======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列2======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列3======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列3======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列3======<NSThread: 0x608000068980>{number = 3, name = (null)}
複製代碼

No.5：NSOperation的其餘操做

取消隊列NSOperationQueue的全部操做，NSOperationQueue對象方法

- (void)cancelAllOperations
複製代碼

取消NSOperation的某個操做，NSOperation對象方法

- (void)cancel
複製代碼

使隊列暫停或繼續

// 暫停隊列
[queue setSuspended:YES];
複製代碼

判斷隊列是否暫停

- (BOOL)isSuspended
複製代碼

暫停和取消不是馬上取消當前操做，而是等當前的操做執行完以後再也不進行新的操做。

No.6：NSOperation的操做依賴

NSOperation有一個很是好用的方法，就是操做依賴。能夠從字面意思理解：某一個操做（operation2）依賴於另外一個操做（operation1），只有當operation1執行完畢，才能執行operation2，這時，就是操做依賴大顯身手的時候了。

- (void)testAddDependency {
    
    // 併發隊列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    // 操做1
    NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"operation1======%@", [NSThread  currentThread]);
        }
    }];
    
    // 操做2
    NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"****operation2依賴於operation1，只有當operation1執行完畢，operation2纔會執行****");
        for (int i = 0; i < 3; i++) {
            NSLog(@"operation2======%@", [NSThread  currentThread]);
        }
    }];
    
    // 使操做2依賴於操做1
    [operation2 addDependency:operation1];
    
    // 把操做加入隊列
    [queue addOperation:operation1];
    [queue addOperation:operation2];
}
複製代碼

運行結果以下，操做2老是在操做1以後執行，成功驗證了上面的說法。

operation1======<NSThread: 0x60800026dec0>{number = 3, name = (null)}
operation1======<NSThread: 0x60800026dec0>{number = 3, name = (null)}
operation1======<NSThread: 0x60800026dec0>{number = 3, name = (null)}
****operation2依賴於operation1，只有當operation1執行完畢，operation2纔會執行****
operation2======<NSThread: 0x60800026dc80>{number = 4, name = (null)}
operation2======<NSThread: 0x60800026dc80>{number = 4, name = (null)}
operation2======<NSThread: 0x60800026dc80>{number = 4, name = (null)}
複製代碼