iOS之多執行緒：執行緒的生命週期，NSThread、GCD、NSOperation的使用與總結

阿新 • • 發佈：2019-12-25

前言：

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

正文：

閒暇之餘，把執行緒的問題整理一下，感覺可能會有點長，所以先自分一下章節，我將會按照以下幾個小節來展開描述：

1.多執行緒的基本概念

2.執行緒的狀態與生命週期

3.多執行緒的對比：pthread、NSThread、GCD、NSOperation

4.NSThread的使用

5.GCD的理解與使用

6.NSOperation的理解與使用

一、多執行緒的基本概念

程序：是計算機中的程式關於某資料集合上的一次執行活動，是系統進行資源分配和排程的基本單位，是作業系統結構的基礎。在當代面向執行緒設計的計算機結構中，程序是執行緒的容器。簡單來說，程序可以看成App執行的一個例項，一個程序可以擁有多個執行緒

。執行緒與程序的一個主要區別是，同一程序內的多個執行緒會共享部分狀態，多個執行緒可以讀寫同一塊記憶體（一個程序無法直接訪問另一程序的記憶體）。
執行緒：是作業系統能夠進行運算排程的最小單位。它被包含在程序之中，是程序中的實際運作單位。一條執行緒指的是程序中一個單一順序的控制流，一個程序中最少有一個執行緒，也可以有多個執行緒，每條執行緒可執行不同的任務。
主執行緒：當一個程式啟動時，就有一個程序被作業系統建立，與此同時一個執行緒也立刻執行，該執行緒通常叫做程式的主執行緒，因為它是程式開始時就執行的，如果你需要再建立執行緒，那麼建立的執行緒就是這個主執行緒的子執行緒。主執行緒的重要性體現在兩方面：1.是產生其他子執行緒的執行緒；2.通常它必須最後完成執行比如執行各種關閉動作。
多執行緒：在同一時刻，一個CPU只能處理1條執行緒，但CPU可以在多條執行緒之間快速的切換，只要切換的足夠快，就造成了多執行緒一同執行的假象。而我們運用多執行緒的目的在於，避免阻塞主執行緒；多執行緒是通過提高資源使用率來提高系統總體的效率。
最後，做個形象的比喻：一個執行的App我們可以看做是奔跑的火車（一個程序），而一個火車最少要有一個火車頭（主執行緒，負責程式的執行，且一個程序至少包含一個執行緒），可以有多節車廂（多執行緒，每一節車廂可以看做是子執行緒，可執行不同的任務）。

二、執行緒的狀態與生命週期

如下圖所示，執行緒的生命週期是：新建、就緒、執行、阻塞、死亡：

執行緒狀態圖

新建：例項化執行緒物件
就緒：向執行緒物件傳送start訊息，執行緒物件被加入可排程執行緒池等待CPU排程。
執行：CPU 負責排程可排程執行緒池中執行緒的執行。執行緒執行完成之前，狀態可能會在就緒和執行之間來回切換。就緒和執行之間的狀態變化由CPU負責，程式設計師不能干預。
阻塞：當滿足某個預定條件時，可以使用休眠或鎖，阻塞執行緒執行。sleepForTimeInterval（休眠指定時長），sleepUntilDate（休眠到指定日期），@synchronized(self)：（互斥鎖等各種鎖）。
死亡：正常死亡，執行緒執行完畢。非正常死亡，當滿足某個條件後，線上程內部中止執行/在主執行緒中止執行緒物件（例如：exit和cancel）
[NSThread exit]：一旦強行終止執行緒，後續的所有程式碼都不會被執行。
[thread cancel]取消：並不會直接取消執行緒，只是給執行緒物件新增 isCancelled 標記。

三、多執行緒的對比：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實現.

四、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聯合使用來跟蹤執行緒的函式呼叫情況，是程式設計除錯的重要手段。

五、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,^{
        // 任務放在這個block裡
        NSLog(@"我是同步執行的任務");
    });
    // 非同步執行任務
    dispatch_async(dispatch_get_global_queue(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，%@",^{
        for(inti =0; i <3; i++) {
            NSLog(@"併發同步2，%@",^{
        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，%@",^{
        for(inti =0; i <3; i++) {
            NSLog(@"併發非同步2，%@",^{
        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，%@",^{
        for(inti =0; i <3; i++) {
            NSLog(@"主佇列非同步2，%@",^{
        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,^{
        // 耗時操作放在這裡，例如下載圖片。（運用執行緒休眠兩秒來模擬耗時操作）
        [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",^{
        for(inti =0; i <3; i++) {
            NSLog(@"柵欄：併發非同步1，%@",^{
        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，%@",^{
        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,block);

dispatch_group_notify(group1,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,^{
        dispatch_sync(queue1,^{
            for(NSInteger i =0; i<3; i++) {
                NSLog(@"同步任務1-:%ld",(long)i);
            }
        });
    });
    dispatch_group_async(group1,^{
            for(NSInteger i =0; i<3; i++) {
                sleep(1);
                NSLog(@"同步任務2-:%ld",(long)i);
            }
        });
    });
    //等待上面的任務全部完成後，會收到通知執行block中的程式碼 （不會阻塞執行緒）
    dispatch_group_notify(group1,^{
        NSLog(@"全部任務執行完成");
    });
}
複製程式碼

group-同步

非同步任務時：

- (void)groupAsync{
    dispatch_queue_t queue1 = dispatch_queue_create("queue1",^{
        dispatch_async(queue1,^{
            for(NSInteger i =0; i<3; i++) {
                sleep(1);
                NSLog(@"非同步任務1,%ld",^{
            for(NSInteger i =0; i<3; i++) {
                sleep(1);
                NSLog(@"非同步任務2,^{
        NSLog(@"全部任務執行完成");
    });
}
複製程式碼

group-非同步

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

其二：

dispatch_group_enter(group);

dispatch_group_leave(group);

dispatch_group_notify(group1,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,(long)i);
        }
        dispatch_group_leave(group2);
    });
    dispatch_group_enter(group2);
    dispatch_sync(queue2,^{
        for(NSInteger i =0; i<3; i++) {
            NSLog(@"同步任務2,(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,(long)i);
        }
        dispatch_group_leave(group2);
    });
    dispatch_group_enter(group2);
    dispatch_async(queue2,^{
        for(NSInteger i =0; i<3; i++) {
            NSLog(@"非同步任務2,^{
        NSLog(@"全部任務執行完成");
    });
}
複製程式碼

group-非同步

結論：dispatch_group_enter(group)、dispatch_group_leave(group) 和dispatch_group_notify(group,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,^(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,^{
        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結束。

六、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次執行",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次執行",i);
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++){
            NSLog(@"任務2 == %@ 第%d次執行",i);
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++){
            NSLog(@"任務3 == %@ 第%d次執行",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次執行",i); // 列印當前執行緒
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模擬耗時操作
            NSLog(@"任務2 == %@ 第%d次執行",i); // 列印當前執行緒
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模擬耗時操作
            NSLog(@"任務3 == %@ 第%d次執行",i); // 列印當前執行緒
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模擬耗時操作
            NSLog(@"任務4 == %@ 第%d次執行",i); // 列印當前執行緒
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模擬耗時操作
            NSLog(@"任務5 == %@ 第%d次執行",i); // 列印當前執行緒
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模擬耗時操作
            NSLog(@"任務6 == %@ 第%d次執行",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次執行",i); // 列印當前執行緒
        }
    }];
    
    NSBlockOperation* B = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模擬耗時操作
            NSLog(@"任務B == %@ 第%d次執行",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次執行",i);
        }
        
        // 回到主執行緒
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
            for (int i = 0; i < 2; i++) {
                [NSThread sleepForTimeInterval:1]; // 模擬耗時操作
                NSLog(@"任務2 == %@ 第%d次執行",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;獲取主佇列。

注意
這裡的暫停和取消（包括操作的取消和佇列的取消）並不代表可以將當前的操作立即取消，而是噹噹前的操作執行完畢之後不再執行新的操作。
暫停和取消的區別在於：暫停操作之後還可以恢復操作，繼續向下執行；而取消操作之後，所有的操作都清空了，無法再接著執行剩下的操作。

總結：
借鑑很多內容，但是有些忘了是誰的，就不一一列舉了。文章有點長，希望大家能耐心的看下來，如果發現問題，也希望大家積極指正，如有不足，也懇請大家告知，謝謝。

參考資料

參考文章
iOS多執行緒全套：執行緒生命週期，多執行緒的四種解決方案，執行緒安全問題，GCD的使用，NSOperation的使用
 iOS 多執行緒: [NSOperation NSOperationQueue] 詳解

書籍目錄——獲取地址加小編微信拉你進iOS開發群：17512010526

作者：陌路賣醬油
來源：www.jianshu.com/p/e03226fe4…

iOS之多執行緒：執行緒的生命週期，NSThread、GCD、NSOperation的使用與總結

前言：

正文：

一、多執行緒的基本概念

二、執行緒的狀態與生命週期

三、多執行緒的對比：pthread、NSThread、GCD、NSOperation

四、NSThread的使用

4.1 NSThread的建立

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

五、GCD的理解與使用

六、NSOperation的理解與使用

6.1 NSOperation,NSOperationQueue 簡介

6.2 NSOperation的三種建立方式

6.2.1 使用NSInvocationOperation建立

6.2.2 使用NSBlockOperation建立

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

6.3 佇列NSOperationQueue

6.4 NSOperation + NSOperationQueue

6.4.1 addOperation新增任務到佇列

6.4.2 addOperationWithBlock新增任務到佇列

6.4.3 maxConcurrentOperationCount控制序列執行、併發執行

6.5 NSOperation的操作依賴

6.6 NSOperation 優先順序

6.7 NSOperation，NSOperationQueue 執行緒間的通訊

6.8 NSOperation、NSOperationQueue 常用屬性和方法歸納

6.8.1 NSOperation 常用屬性和方法

6.8.2 NSOperationQueue 常用屬性和方法

相關推薦