iOS之多線程：線程的生命週期，NSThread、GCD、NSOperation的使用與總結

時間 2019-11-07

標籤 ios 之多線程生命週期 nsthread gcd nsoperation 使用總結欄目 iOS 简体版

原文原文鏈接

前言：

我負責努力，其他交給運氣。html

正文：

閒暇之餘，把線程的問題整理一下，感受可能會有點長，因此先自分一下章節，我將會按照如下幾個小節來展開描述：ios

1.多線程的基本概念程序員

2.線程的狀態與生命週期編程

3.多線程的對比：pthread、NSThread、GCD、NSOperationapi

4.NSThread的使用數組

5.GCD的理解與使用xcode

6.NSOperation的理解與使用安全

1、多線程的基本概念

進程：是計算機中的程序關於某數據集合上的一次運行活動，是系統進行資源分配和調度的基本單位，是操做系統結構的基礎。在當代面向線程設計的計算機結構中，進程是線程的容器。簡單來講，進程能夠當作App執行的一個實例，一個進程能夠擁有多個線程。線程與進程的一個主要區別是，同一進程內的多個線程會共享部分狀態，多個線程能夠讀寫同一塊內存（一個進程沒法直接訪問另外一進程的內存）。bash
線程：是操做系統可以進行運算調度的最小單位。它被包含在進程之中，是進程中的實際運做單位。一條線程指的是進程中一個單一順序的控制流，一個進程中最少有一個線程，也能夠有多個線程，每條線程可執行不一樣的任務。微信
主線程：當一個程序啓動時，就有一個進程被操做系統建立，與此同時一個線程也馬上運行，該線程一般叫作程序的主線程，由於它是程序開始時就執行的，若是你須要再建立線程，那麼建立的線程就是這個主線程的子線程。主線程的重要性體如今兩方面：1.是產生其餘子線程的線程；2.一般它必須最後完成執行好比執行各類關閉動做。
多線程：在同一時刻，一個CPU只能處理1條線程，但CPU能夠在多條線程之間快速的切換，只要切換的足夠快，就形成了多線程一同執行的假象。而咱們運用多線程的目的在於，避免阻塞主線程；多線程是經過提升資源使用率來提升系統整體的效率。
最後，作個形象的比喻：一個運行的App咱們能夠看作是奔跑的火車（一個進程），而一個火車最少要有一個火車頭（主線程，負責程序的運行，且一個進程至少包含一個線程），能夠有多節車箱（多線程，每一節車箱能夠看作是子線程，可執行不一樣的任務）。

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

以下圖所示，線程的生命週期是：新建、就緒、運行、阻塞、死亡：

線程狀態圖

新建：實例化線程對象
就緒：向線程對象發送start消息，線程對象被加入可調度線程池等待CPU調度。
運行：CPU 負責調度可調度線程池中線程的執行。線程執行完成以前，狀態可能會在就緒和運行之間來回切換。就緒和運行之間的狀態變化由CPU負責，程序員不能干預。
阻塞：當知足某個預約條件時，可使用休眠或鎖，阻塞線程執行。sleepForTimeInterval（休眠指定時長），sleepUntilDate（休眠到指定日期），@synchronized(self)：（互斥鎖等各類鎖）。
死亡：正常死亡，線程執行完畢。非正常死亡，當知足某個條件後，在線程內部停止執行/在主線程停止線程對象（例如：exit和cancel）
[NSThread exit]：一旦強行終止線程，後續的全部代碼都不會被執行。
[thread cancel]取消：並不會直接取消線程，只是給線程對象添加 isCancelled 標記。

3、多線程的對比：pthread、NSThread、GCD、NSOperation

線程對比圖

相比於pthread和NSThread，GCD和NSOperation更經常使用一些，因此着重說一下GCD和NSOperation：

GCD 和 NSOperation的區別主要表如今如下幾方面:

GCD是一套 C 語言API,執行和操做簡單高效，所以NSOperation底層也經過GCD實現，這是他們之間最本質的區別.所以若是但願自定義任務，建議使用NSOperation；

依賴關係，NSOperation能夠設置操做之間的依賴(能夠跨隊列設置)，GCD沒法設置依賴關係，不過能夠經過同步來實現這種效果；

KVO(鍵值對觀察)，NSOperation容易判斷操做當前的狀態(是否執行，是否取消等)，對此GCD沒法經過KVO進行判斷；

優先級，NSOperation能夠設置自身的優先級，可是優先級高的不必定先執行，GCD只能設置隊列的優先級，若是要區分block任務的優先級,須要很複雜的代碼才能實現；

繼承，NSOperation是一個抽象類.實際開發中經常使用的是它的兩個子類:NSInvocationOperation和NSBlockOperation，一樣咱們能夠自定義NSOperation，GCD執行任務能夠自由組裝，沒有繼承那麼高的代碼複用度；

效率，直接使用GCD效率確實會更高效，NSOperation會多一點開銷，可是經過NSOperation能夠得到依賴，優先級，繼承，鍵值對觀察這些優點，相對於多的那麼一點開銷確實很划算，魚和熊掌不可得兼，取捨在於開發者本身；

能夠隨時取消準備執行的任務(已經在執行的不能取消),GCD無法中止已經加入queue 的 block(雖然也能實現,可是須要很複雜的代碼)

基於GCD簡單高效,更強的執行能力，操做不太複雜的時候,優先選用GCD;而比較複雜的任務能夠本身經過NSOperation實現.

4、NSThread的使用

4.1 NSThread的建立

NSThread有三種建立方式：

init 建立好以後須要start啓動
detachNewThreadSelector 建立好以後自動啓動
performSelectorInBackground 建立好以後直接啓動

直接上代碼:

- (void)showNSThread{
    /** 方法一，須要start */
    NSThread* thread1 = [[NSThread alloc] initWithTarget:self selector:@selector(doSomething1:) object:@"1"];
    [thread1 start];
     /** 方法二，建立好以後自動啓動 */
    [NSThread detachNewThreadSelector:@selector(doSomething2:) toTarget:self withObject:@"2"];
    /** 方法三，隱式建立，直接啓動 */
    [self performSelectorInBackground:@selector(doSomething3:) withObject:@"3"];
}
- (void)doSomething1:(NSObject*)obj{
    NSLog(@"doSometing1 ---- obj = %@",obj);
}
- (void)doSomething2:(NSObject*)obj{
    NSLog(@"doSometing2 ---- obj = %@",obj);
}
- (void)doSomething3:(NSObject*)obj{
    NSLog(@"doSometing3 ---- obj = %@",obj);
}
複製代碼

4.2 NSThread的一些屬性、實例方法、類方法**

屬性：

/**
每一個線程都維護了一個鍵-值的字典,它能夠在線程裏面的任何地方被訪問。
可使用該字典來保存一些信息,這些信息在整個線程的執行過程當中都保持不變。
好比,你可使用它來存儲在你的整個線程過程當中 Run loop 裏面屢次迭代的狀態信息。
NSThread實例可使用一下方法:
NSMutableDictionary *dict = [thread threadDictionary]; 
*/
@property (readonly, retain) NSMutableDictionary *threadDictionary;

@property double threadPriority ; //優先級

/**NSQualityOfService說明:
NSQualityOfServiceUserInteractive：最高優先級,主要用於提供交互UI的操做,好比處理點擊事件,繪製圖像到屏幕上
NSQualityOfServiceUserInitiated：次高優先級，主要用於執行須要當即返回的任務
NSQualityOfServiceDefault：默認優先級，當沒有設置優先級的時候，線程默認優先級
NSQualityOfServiceUtility：普通優先級，主要用於不須要當即返回的任務
NSQualityOfServiceBackground：後臺優先級，用於徹底不緊急的任務
*/
@property NSQualityOfService qualityOfService; //線程優先級

@property (nullable, copy) NSString *name;//線程名稱

@property NSUInteger stackSize ;//線程使用棧區大小，默認是512K

@property (readonly, getter=isExecuting) BOOL executing;//線程是否正在執行

@property (readonly, getter=isFinished) BOOL finished;//線程是否執行結束

@property (readonly, getter=isCancelled) BOOL cancelled;//線程是否可被取消

複製代碼

實例方法：

-(void)start; //啓動線程（init建立的線程，需start啓動，不自行運行）

-(BOOL)isMainThread; //是否爲主線程

-(void)setName:(NSString *)n; //設置線程名稱

-(void)cancel ; //取消線程

-(void)main ; //線程的入口函數

-(void)isExecuting; //判斷線程是否正在執行

-(void)isFinished; //判斷線程是否已經結束

-(void)isCancelled; //判斷線程是否撤銷
複製代碼

類方法：

+(void)currentThread; //獲取當前線程

+(BOOL)isMultiThreaded; //當前代碼運行所在線程是不是子線程

+(void)sleepUntilDate:(NSDate *)date; //當前代碼所在線程睡到指定時間

+(void)sleepForTimeInterval:(NSTimeInterval)ti; //當前線程睡多長時間

+(void)exit; //退出當前線程

+(double)threadPriority; //設置當前線程優先級
/**給當前線程設定優先級，調度優先級的取值範圍是0.0 ~ 1.0，
默認0.5，值越大，優先級越高。*/
+(BOOL)setThreadPriority:(double)p; 
/**
線程的調用都會有函數的調用，函數的調用就會有棧返回地址的記錄，
在這裏返回的是函 數調用返回的虛擬地址，
說白了就是在該線程中函數調用的虛擬地址的數組
*/
+(NSArray *)callStackReturnAddresses;

+(NSArray *)callStackSymbols; //同上面的方法同樣，只不過返回的是該線程調用函數的名字數字
複製代碼

注：callStackReturnAddress和callStackSymbols這兩個函數能夠同NSLog聯合使用來跟蹤線程的函數調用狀況，是編程調試的重要手段。

5、GCD的理解與使用

5.1 GCD的基本概念

任務（block）：任務就是將要在線程中執行的代碼，將這段代碼用block封裝好，而後將這個任務添加到指定的執行方式（同步執行和異步執行），等待CPU從隊列中取出任務放到對應的線程中執行。
同步（sync）：一個接着一個，前一個沒有執行完，後面不能執行，不開線程。
異步（async）：開啓多個新線程，任務同一時間能夠一塊兒執行。異步是多線程的代名詞。
隊列：裝載線程任務的隊形結構。(系統以先進先出的方式調度隊列中的任務執行)。在GCD中有兩種隊列：串行隊列和併發隊列。
併發隊列：線程能夠同時一塊兒進行執行。其實是CPU在多條線程之間快速的切換。（併發功能只有在異步（dispatch_async）函數下才有效）
串行隊列：線程只能依次有序的執行。
GCD總結：添加任務（線程中執行的操做block）且指定執行任務的方式(異步dispatch_async，同步dispatch_sync)，並將線程添加進隊列(本身建立或使用全局併發隊列)。

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

//串行隊列
dispatch_queue_t queue1 = dispatch_queue_create("queue1",DISPATCH_QUEUE_SERIAL);

//並行隊列
dispatch_queue_t queue2 = dispatch_queue_create("queue2",DISPATCH_QUEUE_CONCURRENT);
複製代碼

GCD的隊列還有另外兩種：

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

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);
複製代碼

5.3 同步、異步&任務

同步（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(@"我是異步執行的任務");
    });
複製代碼

5.4 GCD的使用
因爲有多種隊列（串行、併發、主隊列）和兩種執行方式（同步、異步），因此他們之間有多種組合方式：串行同步、串行異步、併發同步、併發異步、主隊列同步、主隊列異步。

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

/** 串行同步 */
- (void)serialSynchronization{
    // 串行隊列
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
    // 同步執行
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"串行同步1,%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"串行同步2,%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主線程執行函數1");
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"串行同步3,%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主線程執行函數2");
}
複製代碼

執行結果爲順序執行，且沒有開闢新線程，都在主線程，阻塞了主線程，如圖：

串行同步執行結果

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

/** 串行異步 */
- (void)serialAsynchronous {
    // 串行隊列
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
    // 異步執行
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"串行異步1,%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"串行異步2,%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主線程執行函數1");
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"串行異步3,%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主線程執行函數2");
}
複製代碼

執行結果以下，由於是串行隊列，因此異步線程按照順序執行；可是異步開闢了新的子線程，因此沒有阻塞主線程：

串行異步執行結果

5.4.3 併發同步

/** 併發同步 */ 
- (void)concurrentSynchronization {
    // 併發隊列
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    // 同步執行
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"併發同步1，%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"併發同步2，%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主線程執行函數1");
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"併發同步3，%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主線程執行函數2");
}
複製代碼

執行結果以下，雖然咱們選擇的併發隊列，可是由於是同步線程，因此任務依然是順序執行，沒有開闢新線程，依然在主線程上執行，且阻塞了主線程：

併發同步執行結果

5.4.4 併發異步

/** 併發異步 */
- (void)concurrentAsynchronization {
    // 併發隊列
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    // 異步執行
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"併發異步1，%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"併發異步2，%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主線程執行函數1");
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"併發異步3，%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主線程執行函數2");
}
複製代碼

執行結果以下，執行順序無序（併發）、開闢了多條子線程、沒有阻塞主線程：

併發異步執行結果

5.4.5 主隊列同步

/** 主隊列同步 */
- (void)syncMain {
    // 主隊列
    NSLog(@"主線程執行函數1");
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"主隊列同步1，%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主線程執行函數2");
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"主隊列同步2，%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主線程執行函數3");
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"主隊列同步3，%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主線程執行函數4");
}
複製代碼

執行結果以下，xcode8以後，不會阻塞，會崩潰。不過話說回來，主隊列同步形成死鎖，咱們都知道是由於相互等待，但是阻塞、等待的是誰呢？這裏要說的是：阻塞的是隊列, 不是線程,咱們可能會疑惑，爲何其餘串行同步不會死鎖：輸出block確實也在主線程執行, 若是sync阻塞的是主線程, 那按理這樣確實會死鎖, 但實際上sync阻塞的是主隊列, 而不是主線程。其餘串行同步運行結果是, dispatch_sync運行在主隊列, 而其block運行在queue隊列, 雖然兩個隊列都是由主線程執行, 因爲dispatch_sync阻塞的只是主隊列, block在queue隊列由主線程執行完並返回, 從而dispatch_sync返回, 以後主隊列結束阻塞繼續執行下面任務. 此處queue隊列是運行在主線程的另外一串行隊列（是否是很懵~~ 哈哈~~ 看下面模擬阻塞代碼會清楚一些）。

咱們本身模擬出主隊列阻塞可能更容易理解：

dispatch_queue_t queue = dispatch_queue_create("queue1", DISPATCH_QUEUE_SERIAL);//能夠把queue理解爲主隊列
dispatch_sync(queue, ^{//能夠把這理解爲主線程
    dispatch_sync(queue, ^{//主線程中主隊列同步   
    });
});
複製代碼

這樣就把串行隊列queue阻塞了.

主隊列同步執行結果

5.4.6 主隊列異步

/** 主隊列異步 */
- (void)asyncMain {
    // 主隊列
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"主隊列異步1，%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"主隊列異步2，%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主線程執行函數1");
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"主隊列異步3，%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主線程執行函數2");
}
複製代碼

執行結果以下，在主線程中任務按順序執行，但並無阻塞主線程：

主隊列異步

咱們經過上面六種組合，能夠看到，同步不論串行仍是併發，都沒有開闢新線程，運行在主線程上，且都是順序執行，因此並無併發效果。異步不論串行仍是併發，都開啓了新線程（子線程），可是可見的是，多條異步串行，只開闢了一個子線程，多條異步併發，開啓了多條子線程。主隊列異步，並無開啓子線程，且爲有序串行執行，但並無阻塞主線程。

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

- (IBAction)communicationBetweenThread:(id)sender {
    // 異步
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        // 耗時操做放在這裏，例以下載圖片。（運用線程休眠兩秒來模擬耗時操做）
        [NSThread sleepForTimeInterval:2];
        NSString *picURLStr = @"https://123.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;
        });
    });
}
複製代碼

5.4.8 GCD柵欄
當任務須要異步進行，可是這些任務須要分紅兩組來執行，第一組完成以後才能進行第二組的操做。這時候就用了到GCD的柵欄方法dispatch_barrier_async和dispatch_barrier_sync詳情可查閱官方文檔。他們的不一樣之處在於：

dispatch_barrier_sync 將本身的任務插入到隊列的時候，須要等待本身的任務結束以後纔會繼續插入被寫在它後面的任務，而後執行它們。

dispatch_barrier_async 將本身的任務插入到隊列以後，不會等待本身的任務結束，它會繼續把後面的任務插入到隊列，而後等待本身的任務結束後才執行後面任務。

實際上相似於同步異步，下面以dispatch_barrier_async爲例：

- (void)barrierGCD {
    // 併發隊列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    // 異步執行
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"柵欄：併發異步1，%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"柵欄：併發異步2，%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_barrier_async(queue, ^{
        NSLog(@"------------barrier------------%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"柵欄：併發異步3，%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"柵欄：併發異步4，%@",[NSThreadcurrentThread]);
        }
    });
}
複製代碼

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

柵欄執行結果

須要注意的是：
dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block)，柵欄函數中傳入的參數隊列必須是由 dispatch_queue_create 方法建立的隊列，不然，與dispatch_async無異，起不到「柵欄」的做用了，對於dispatch_barrier_sync也是同理。

5.4.9 GCD隊列組
平時在進行多線程處理任務時，有時候但願多個任務之間存在着一種聯繫，但願在全部的任務執行完後作一些總結性處理。那麼就能夠將多個任務放在一個任務組中進行統一管理。dispatch提供了相應的API供咱們完成這一需求。

（1）dispatch_group_t相關屬性介紹：

1.dispatch_group_async(group, queue, block);
將block任務添加到queue隊列，並被group組管理

2.dispatch_group_enter(group);
聲明dispatch_group_enter(group)下面的任務由group組管理，group組的任務數+1

3.dispatch_group_leave(group);
相應的任務執行完成，group組的任務數-1

4.dispatch_group_create();
建立一個group組

5.dispatch_group_wait(group1, DISPATCH_TIME_FOREVER);
當前線程暫停，等待dispatch_group_wait(group1, DISPATCH_TIME_FOREVER)上面的任務執行完成後，線程才繼續執行。

6.dispatch_group_notify(group1, queue1,block);
監聽group組中任務的完成狀態，當全部的任務都執行完成後，觸發block塊，執行總結性處理。
複製代碼

（2）常見用法的區別
在使用group組處理任務時，常見的有兩種組合。

其一：

dispatch_group_async(group, queue, block);

dispatch_group_notify(group1, queue1, block);
複製代碼

在這種組合下，根據任務是同步、異步又分爲兩種，這兩種組合的執行代碼與運行結果以下：

同步任務時：

- (void)groupSync{
    dispatch_queue_t queue1 = dispatch_queue_create("queue1", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_t group1 = dispatch_group_create();
    dispatch_group_async(group1, queue1, ^{
        dispatch_sync(queue1, ^{
            for(NSInteger i =0; i<3; i++) {
                NSLog(@"同步任務1-:%ld",(long)i);
            }
        });
    });
    dispatch_group_async(group1, queue1, ^{
        dispatch_sync(queue1, ^{
            for(NSInteger i =0; i<3; i++) {
                sleep(1);
                NSLog(@"同步任務2-:%ld",(long)i);
            }
        });
    });
    //等待上面的任務所有完成後，會收到通知執行block中的代碼 （不會阻塞線程）
    dispatch_group_notify(group1, queue1, ^{
        NSLog(@"所有任務執行完成");
    });
}
複製代碼

group-同步

異步任務時：

- (void)groupAsync{
    dispatch_queue_t queue1 = dispatch_queue_create("queue1", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_t group1 = dispatch_group_create();
    dispatch_group_async(group1, queue1, ^{
        dispatch_async(queue1, ^{
            for(NSInteger i =0; i<3; i++) {
                sleep(1);
                NSLog(@"異步任務1,%ld",(long)i);
            }
        });
    });
    dispatch_group_async(group1, queue1, ^{
        dispatch_async(queue1, ^{
            for(NSInteger i =0; i<3; i++) {
                sleep(1);
                NSLog(@"異步任務2,%ld",(long)i);
            }
        });
    });
    //等待上面的任務所有完成後，會收到通知執行block中的代碼 （不會阻塞線程）
    dispatch_group_notify(group1, queue1, ^{
        NSLog(@"所有任務執行完成");
    });
}
複製代碼

group-異步

結論：dispatch_group_async(group, queue, block) 和 dispatch_group_notify(group1, queue1, block) 組合在執行同步任務時正常，在執行異步任務時不正常。

其二：

dispatch_group_enter(group);

dispatch_group_leave(group);

dispatch_group_notify(group1, queue1,block);
複製代碼

一樣的在這種組合下，根據任務是同步、異步也分爲兩種，這兩種組合的執行代碼與運行結果以下：

同步任務時：

- (void)groupSyncEnter {
    dispatch_queue_t queue2 = dispatch_queue_create("queue2", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_t group2 = dispatch_group_create();
    dispatch_group_enter(group2);
    dispatch_sync(queue2, ^{
        for(NSInteger i =0; i<3; i++) {
            NSLog(@"同步任務1,%ld",(long)i);
        }
        dispatch_group_leave(group2);
    });
    dispatch_group_enter(group2);
    dispatch_sync(queue2, ^{
        for(NSInteger i =0; i<3; i++) {
            NSLog(@"同步任務2,%ld",(long)i);
        }
        dispatch_group_leave(group2);
    });
    //等待上面的任務所有完成後，會收到通知執行block中的代碼 （不會阻塞線程）
    dispatch_group_notify(group2, queue2, ^{
        NSLog(@"所有任務執行完成");
    });
}
複製代碼

group-同步

異步任務時：

- (void)groupAsyncEnter{
    dispatch_queue_t queue2 = dispatch_queue_create("queue2", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_t group2 = dispatch_group_create();
    dispatch_group_enter(group2);
    dispatch_async(queue2, ^{
        for(NSInteger i =0; i<3; i++) {
            NSLog(@"異步任務1,%ld",(long)i);
        }
        dispatch_group_leave(group2);
    });
    dispatch_group_enter(group2);
    dispatch_async(queue2, ^{
        for(NSInteger i =0; i<3; i++) {
            NSLog(@"異步任務2,%ld",(long)i);
        }
        dispatch_group_leave(group2);
    });
    //等待上面的任務所有完成後，會收到通知執行block中的代碼 （不會阻塞線程）
    dispatch_group_notify(group2, queue2, ^{
        NSLog(@"所有任務執行完成");
    });
}
複製代碼

group-異步

結論：dispatch_group_enter(group)、dispatch_group_leave(group) 和dispatch_group_notify(group, queue,block) 組合在執行同步任務時正常，在執行異步任務時正常。

5.5 GCD一些經常使用API
除了以上說道的api以外，還有一些經常使用CGD的api：

/**兩個做用：
第一，變動隊列的執行優先級；
第二，目標隊列能夠成爲原隊列的執行階層。*/
dispatch_set_target_queue 

 /**想在指定時間後執行處理的狀況，可以使用dispatch_after函數來實現。
須要注意的是，dispatch_after函數並非在指定時間後執行處理，
而只是在指定時間追加處理到Dispatch Queue。*/
dispatch_after

dispatch_apply//第一個參數爲重複次數，第二個參數爲追加對象的Dispatch，第三個參數爲追加的處理
dispatch_apply(10, queue, ^(size_t index) {
    NSLog(@"%zu",index);
});

dispatch_suspend(queue)//函數掛起指定的Dispatch Queue

dispatch_resume(queue)//函數恢復指定的Dispatch Queue
 
dispatch_once//函數是保證在應用程序執行中只執行一次指定處理的API
複製代碼

5.6 GCD終止線程
若是還未執行的子線程能夠用dispatch_block_cancel來取消（須要注意必須用dispatch_block_create建立dispatch_block_t）

- (void)stopSync{
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
    dispatch_block_t block1 = dispatch_block_create(0, ^{
        NSLog(@"block1 begin");
        [NSThread sleepForTimeInterval:3];
        NSLog(@"block1 end");
    });

    dispatch_block_t block2 = dispatch_block_create(0, ^{
        NSLog(@"block2 ");
    });
    dispatch_async(queue, block1);
    dispatch_async(queue, block2);
    //取消執行block2
    dispatch_block_cancel(block2);
}
複製代碼

運行結果以下：

image

可是，若是執行中的線程，咱們該怎麼讓其退出呢？方法以下：

- (void)stopAsync {
    __block BOOL isFinish =NO;
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        for(long i=0; i<10000; i++) {
            NSLog(@"正在執行第 %ld 次",i);
            sleep(1);
            if(isFinish ==YES) {
                NSLog(@"已經終止了");
                return;
            }
        };
    });
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW,(int64_t)(10 * NSEC_PER_SEC)),dispatch_get_main_queue(), ^{
        NSLog(@"我要中止啦");
        isFinish =YES;
    });
}
複製代碼

執行結果：

image

方法很簡單，線程外設置__block變量，配合線程中return結束。

6、NSOperation的理解與使用

6.1 NSOperation, NSOperationQueue 簡介

NSOperation須要配合NSOperationQueue來實現多線程；NSOperation，NSOperationQueue 是蘋果提供給咱們的一套多線程解決方案，是基於 GCD 更高一層的封裝，徹底面向對象。可是比 GCD 更簡單易用，代碼可讀性更高。

既然是基於 GCD 的更高一層的封裝。那麼，GCD 的一些概念一樣適用於 NSOperation，NSOperationQueue。在 NSOperation，NSOperationQueue 中也有相似於任務（操做）和隊列（操做隊列）的概念。

操做（Operation）
- 執行操做的意思，即在線程中執行的那段代碼。在 GCD 中是放在 block 中的。在 NSOperation 中，咱們使用 NSOperation 子類NSInvocationOperation，NSBlockOperation，或者時自定義子類來封裝操做。
操做隊列（Operation Queue）
- 這裏的隊列指操做隊列，即用來存放操做的隊列。不一樣於 GCD中的調度隊列 FIFO（先進先出）的原則。NSOperationQueue 對於添加到隊列中的操做，首先進入準備就緒的狀態（就緒狀態取決於操做之間的依賴關係），而後進入就緒狀態的操做的開始執行順序（非結束執行順序），由操做之間相對的優先級決定（優先級是操做對象自身的屬性）；
- 操做隊列經過設置最大併發操做數（maxConcurrentOperationCount）來控制併發，串行；
- NSOperationQueue 爲咱們提供了兩種不一樣類型的隊列：主隊列和自定義隊列。主隊列運行在主線程之上，而自定義隊列在後臺執行。

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

建立操做：先將要執行的操做封裝到一個 NSOperation 對象中

建立隊列：建立 NSOperationQueue 對象。

將操做加入到隊列中：將 NSOpeartion 對象添加到 NSOperationQueue 對象中。

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

使用子類NSInvocationOperation

使用子類NSBlockOperation

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

6.2 NSOperation的三種建立方式

6.2.1 使用NSInvocationOperation建立

//NSInvocationOperation使用
- (void)useNSInvocationOperation{
    //建立NSInvocationOperation並關聯方法
    NSInvocationOperation* opratin = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperationAction) object:nil];
    //執行操做
    [opratin start];
}
- (void)invocationOperationAction{
    NSLog(@"NSInvocationOperation任務，沒有加入隊列==%@", [NSThread currentThread]);
}
複製代碼

執行結果以下，獲得結論：程序在主線程執行，沒有開啓新線程。這是由於 NSOperation 多線程的使用須要配合隊列 NSOperationQueue ，在不使用 NSOperationQueue ，單獨使用 NSOperation 的狀況下，系統同步執行操做。

執行結果

6.2.2 使用NSBlockOperation建立

//NSBlockOperation使用
- (void)useNSBlockOperation{
    //建立NSBlockOperation並把任務放到block中
    NSBlockOperation* operation = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"NSInvocationOperation任務，沒有加入隊列==%@", [NSThread currentThread]);
    }];
    //執行操做
    [operation start];
}
複製代碼

執行結果以下，結論上同，不在闡述。

執行結果

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

//NSBlockOperation使用
- (void)useNSBlockOperation{
    //建立NSBlockOperation並把任務放到block中
    NSBlockOperation* operation = [NSBlockOperation blockOperationWithBlock:^{
        for(int i = 0; i < 3; i++){
            NSLog(@"NSInvocationOperation任務==%@", [NSThread currentThread]);
        }
//        NSLog(@"NSInvocationOperation任務，沒有加入隊列==%@", [NSThread currentThread]);
    }];
    [operation addExecutionBlock:^{
        for(int i = 0; i < 3; i++){
            NSLog(@"addExecutionBlock方法添加任務1==%@", [NSThread currentThread]);
        }
    }];
    [operation addExecutionBlock:^{
        for(int i = 0; i < 3; i++){
            NSLog(@"addExecutionBlock方法添加任務2==%@", [NSThread currentThread]);
        }
    }];
    [operation addExecutionBlock:^{
        for(int i = 0; i < 3; i++){
            NSLog(@"addExecutionBlock方法添加任務3==%@", [NSThread currentThread]);
        }
    }];
    //執行操做
    [operation start];
}
複製代碼

執行結果以下，(第二個執行結果是添加了十個操做，執行了兩次出現的結果...)

執行結果1

執行結果2

獲得結論：

經過addExecutionBlock能夠爲 NSBlockOperation 添加額外的操做。這些操做（包括blockOperationWithBlock中的操做）能夠再不一樣的線程中同時（併發）執行。只有當全部相關的操做已經執行完成時，才視爲完成。
若是添加的操做多的話，blockOperationWithBlock:中的操做也可能會在其餘線程（非當前線程）中執行，這是由系統決定的，並非說添加到blockOperationWithBlock:中的操做必定會在當前線程中執行。（第二張執行結果，好奇的能夠試試，嘿嘿...）
NSBlockOperation是否會開啓新線程，取決於操做的個數。若是添加的操做的個數多，就會開啓新線程。開啓的線程數是由系統來決定的。

6.2.3 使用繼承自NSOperation的子類建立

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

/*******************"OurNSOperation.h"*************************/
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@interface OurNSOperation : NSOperation
@end
NS_ASSUME_NONNULL_END

/*******************"OurNSOperation.m"*************************/
#import "OurNSOperation.h"
@implementation OurNSOperation
- (void)main{
    for(int i = 0; i < 3; i++){
        NSLog(@"NSOperation的子類OurNSOperation==%@",[NSThread currentThread]);
    }
}
@end
/*******"回到主控制器導入頭文件並使用OurNSOperation"********/
- (void)useOurNSOperation{
    //建立OurNSOperation對象
    OurNSOperation* operation = [[OurNSOperation alloc] init];
    //開始執行
    [operation start];
}
複製代碼

運行結果以下，依然是在主線程執行。因此，NSOperation是須要配合隊列NSOperationQueue來實現多線程的。

執行結果

6.3 隊列NSOperationQueue

NSOperationQueue只有兩種隊列：主隊列、自定義隊列。自定義隊列包含了串行和併發。

主隊列的建立以下：主隊列上的任務是在主線程執行的。
NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];
自定義隊列（非主隊列）的建立以下:加入到自定義隊列中的任務，默認就是併發，開啓多線程。
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
須要注意的是：
- 非主隊列（自定義隊列）能夠實現串行或並行。
- 隊列NSOperationQueue有一個參數叫作最大併發數：maxConcurrentOperationCount。
- maxConcurrentOperationCount默認爲-1，直接併發執行，因此加入到‘非主隊列’中的任務默認就是併發，開啓多線程。
- 當maxConcurrentOperationCount爲1時，則表示不開線程，也就是串行。
- 當maxConcurrentOperationCount大於1時，進行併發執行。
- 系統對最大併發數有一個限制，因此即便程序員把maxConcurrentOperationCount設置的很大，系統也會自動調整。因此把最大併發數設置的很大是沒有意義的。

6.4 NSOperation + NSOperationQueue

NSOperation 須要配合 NSOperationQueue 來實現多線程,因此把任務加入隊列，這纔是NSOperation的常規使用方式。

6.4.1 addOperation添加任務到隊列

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

- (void)useAddOperation {
    NSOperationQueue* queue = [[NSOperationQueue alloc] init];
    NSInvocationOperation* operation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperationActions) object:nil];
    NSBlockOperation* blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        for(int i = 0; i < 3; i++){
            NSLog(@"NSBlockOperation任務 == %@ 第%d次執行",[NSThread currentThread],i);
        }
    }];
    
    [queue addOperation:operation];
    [queue addOperation:blockOperation];
}

- (void)invocationOperationActions {
    for (int i = 0; i < 3; i++){
        NSLog(@"NSInvocationOperation任務 == %@ 第%d次執行",[NSThread currentThread],i);
    }
}
複製代碼

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

執行結果

6.4.2 addOperationWithBlock添加任務到隊列

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

- (void)useAddOperationWithBlock{
    NSOperationQueue* queue = [[NSOperationQueue alloc] init];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++){
            NSLog(@"任務1 == %@ 第%d次執行",[NSThread currentThread],i);
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++){
            NSLog(@"任務2 == %@ 第%d次執行",[NSThread currentThread],i);
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++){
            NSLog(@"任務3 == %@ 第%d次執行",[NSThread currentThread],i);
        }
    }];
}
複製代碼

執行結果以下，使用 addOperationWithBlock:將操做加入到操做隊列後可以開啓新線程，進行併發執行。

執行結果

6.4.3 maxConcurrentOperationCount控制串行執行、併發執行

maxConcurrentOperationCount,叫作最大併發操做數，用來控制一個特定隊列中能夠有多少個操做同時參與併發執行。

注意：這裏maxConcurrentOperationCount控制的不是併發線程的數量，而是一個隊列中同時能併發執行的最大操做數。並且一個操做也並不是只能在一個線程中運行。(6.3中作過一些介紹，再也不闡述)

- (void)useMaxConcurrentOperationCount{
    NSOperationQueue* queue = [[NSOperationQueue alloc] init];
    
    //設置併發數
    queue.maxConcurrentOperationCount = 1;//串行隊列
//    queue.maxConcurrentOperationCount = 4;//並行隊列
//    queue.maxConcurrentOperationCount = 100;//並行隊列
    
    // 使用 addOperationWithBlock添加操做到隊列中
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模擬耗時操做
            NSLog(@"任務1 == %@ 第%d次執行",[NSThread currentThread],i); // 打印當前線程
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模擬耗時操做
            NSLog(@"任務2 == %@ 第%d次執行",[NSThread currentThread],i); // 打印當前線程
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模擬耗時操做
            NSLog(@"任務3 == %@ 第%d次執行",[NSThread currentThread],i); // 打印當前線程
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模擬耗時操做
            NSLog(@"任務4 == %@ 第%d次執行",[NSThread currentThread],i); // 打印當前線程
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模擬耗時操做
            NSLog(@"任務5 == %@ 第%d次執行",[NSThread currentThread],i); // 打印當前線程
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模擬耗時操做
            NSLog(@"任務6 == %@ 第%d次執行",[NSThread currentThread],i); // 打印當前線程
        }
    }];
}
複製代碼

最大併發操做數爲1時

最大併發操做數爲1時
最大併發操做數爲4時

最大併發操做數爲4時
最大併發操做數爲100時

最大併發操做數爲100時
能夠看出：當最大併發操做數爲1時，操做是按照順序串行執行的，而且一個操做完成以後，下一個操做纔開始執行。當最大操做併發數大於1時，操做是併發執行的，能夠同時執行多個操做。並且開啓線程數量是由系統決定的，不須要咱們來管理。

6.5 NSOperation的操做依賴

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

- (void)addDependency:(NSOperation *)op;添加依賴，使當前操做依賴於操做 op 的完成
- (void)removeDependency:(NSOperation *)op;移除依賴，取消當前操做對象操做 op 的依賴
@property (readonly, copy) NSArray<NSOperation *> *dependencies;在當前操做開始執行以前完成執行的全部 NSOperation 對象數組。

代碼示例：A 執行完操做，B 才能執行操做。

- (void)useAddDependency{
    // 建立隊列
    NSOperationQueue* queue = [[NSOperationQueue alloc] init];
    
    queue.maxConcurrentOperationCount = 4;//並行隊列
    
    // 建立操做
    NSBlockOperation* A = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模擬耗時操做
            NSLog(@"任務A == %@ 第%d次執行",[NSThread currentThread],i); // 打印當前線程
        }
    }];
    
    NSBlockOperation* B = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模擬耗時操做
            NSLog(@"任務B == %@ 第%d次執行",[NSThread currentThread],i); // 打印當前線程
        }
    }];
    
    // 添加依賴
    [B addDependency:A];    // 讓B依賴於A,則先執行A,再執行B.
    
    // 添加操做到隊列中
    [queue addOperation:A];
    [queue addOperation:B];
}
複製代碼

執行結果:

執行結果

按照6.4.3所述，咱們設置了 queue.maxConcurrentOperationCount = 4 ;本應並行執行，可是設置依賴後，B等A執行完畢後才執行的。

6.6 NSOperation 優先級

NSOperation 提供了queuePriority(優先級)屬性，queuePriority 屬性適用於同一操做隊列中的操做，不適用於不一樣操做隊列中的操做。默認狀況下，全部新建立的操做對象優先級都是NSOperationQueuePriorityNormal。可是咱們能夠經過setQueuePriority:方法來改變當前操做在同一隊列中的執行優先級。

// 優先級的取值
typedef NS_ENUM(NSInteger, NSOperationQueuePriority) {
    NSOperationQueuePriorityVeryLow = -8L,
    NSOperationQueuePriorityLow = -4L,
    NSOperationQueuePriorityNormal = 0,
    NSOperationQueuePriorityHigh = 4,
    NSOperationQueuePriorityVeryHigh = 8
};
複製代碼

對於添加到隊列中的操做，首先進入準備就緒的狀態（就緒狀態取決於操做之間的依賴關係），而後進入就緒狀態的操做的開始執行順序（非結束執行順序）由操做之間相對的優先級決定（優先級是操做對象自身的屬性）。

queuePriority 屬性決定了進入準備就緒狀態下的操做之間的開始執行順序。而且，優先級不能取代依賴關係。
若是一個隊列中既包含高優先級操做，又包含低優先級操做，而且兩個操做都已經準備就緒，那麼隊列先執行高優先級操做。
若是，一個隊列中既包含了準備就緒狀態的操做，又包含了未準備就緒的操做，未準備就緒的操做優先級比準備就緒的操做優先級高。那麼，雖然準備就緒的操做優先級低，也會優先執行。優先級不能取代依賴關係。若是要控制操做間的啓動順序，則必須使用依賴關係。

6.7 NSOperation，NSOperationQueue 線程間的通訊

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

//線程間通訊
- (void)useMainQueue {
    // 建立隊列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    // 添加操做
    [queue addOperationWithBlock:^{
        // 異步執行耗時操做
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模擬耗時操做
            NSLog(@"任務1 == %@ 第%d次執行",[NSThread currentThread],i);
        }
        
        // 回到主線程
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
            for (int i = 0; i < 2; i++) {
                [NSThread sleepForTimeInterval:1]; // 模擬耗時操做
                NSLog(@"任務2 == %@ 第%d次執行",[NSThread currentThread],i);
            }
        }];
    }];
}
複製代碼

執行結果：

執行結果

能夠看出：經過線程間的通訊，先在其餘線程中執行操做，等操做執行完了以後再回到主線程執行主線程的相應操做。

6.8 NSOperation、NSOperationQueue 經常使用屬性和方法概括

6.8.1 NSOperation 經常使用屬性和方法

取消操做方法
- - (void)cancel;可取消操做，實質是標記 isCancelled 狀態。
判斷操做狀態方法
- - (BOOL)isFinished;判斷操做是否已經結束。
- - (BOOL)isCancelled; 判斷操做是否已經標記爲取消。
- - (BOOL)isExecuting;判斷操做是否正在在運行。
- - (BOOL)isReady;判斷操做是否處於準備就緒狀態，這個值和操做的依賴關係相關。
操做同步
- - (void)waitUntilFinished; 阻塞當前線程，直到該操做結束。可用於線程執行順序的同步。
- - (void)setCompletionBlock:(void (^)(void))block;completionBlock 會在當前操做執行完畢時執行 completionBlock。
- - (void)addDependency:(NSOperation *)op; 添加依賴，使當前操做依賴於操做 op 的完成。
- - (void)removeDependency:(NSOperation *)op; 移除依賴，取消當前操做對操做 op 的依賴。
- @property (readonly, copy) NSArray<NSOperation *> *dependencies; 在當前操做開始執行以前完成執行的全部操做對象數組。

6.8.2 NSOperationQueue 經常使用屬性和方法

取消/暫停/恢復操做
- - (void)cancelAllOperations;能夠取消隊列的全部操做。
- - (BOOL)isSuspended; 判斷隊列是否處於暫停狀態。 YES 爲暫停狀態，NO 爲恢復狀態。
- - (void)setSuspended:(BOOL)b; 可設置操做的暫停和恢復，YES 表明暫停隊列，NO 表明恢復隊列。
操做同步
- - (void)waitUntilAllOperationsAreFinished; 阻塞當前線程，直到隊列中的操做所有執行完畢。
添加/獲取操做
- - (void)addOperationWithBlock:(void (^)(void))block;向隊列中添加一個 NSBlockOperation 類型操做對象。
- - (void)addOperations:(NSArray *)ops waitUntilFinished:(BOOL)wait; 向隊列中添加操做數組，wait 標誌是否阻塞當前線程直到全部操做結束
- - (NSArray *)operations; 當前在隊列中的操做數組（某個操做執行結束後會自動從這個數組清除）。
- - (NSUInteger)operationCount; 當前隊列中的操做數。
獲取隊列
- + (id)currentQueue; 獲取當前隊列，若是當前線程不是在 NSOperationQueue 上運行則返回 nil。
- + (id)mainQueue;獲取主隊列。