iOS多執行緒全套:執行緒生命週期,多執行緒的四種解決方案,執行緒安全問題,GCD的使用,NSOperation的使用

wuhao丶發表於2019-03-03

目的

本文主要是分享iOS多執行緒的相關內容,為了更系統的講解,將分為以下7個方面來展開描述。

  1. 多執行緒的基本概念
  2. 執行緒的狀態與生命週期
  3. 多執行緒的四種解決方案:pthread,NSThread,GCD,NSOperation
  4. 執行緒安全問題
  5. NSThread的使用
  6. GCD的理解與使用
  7. NSOperation的理解與使用

Demo 在這裡:WHMultiThreadDemo
Demo的執行gif圖如下:

example5.gif
example5.gif

一、多執行緒的基本概念

程式:可以理解成一個執行中的應用程式,是系統進行資源分配和排程的基本單位,是作業系統結構的基礎,主要管理資源。

執行緒:是程式的基本執行單元,一個程式對應多個執行緒。

主執行緒:處理UI,所有更新UI的操作都必須在主執行緒上執行。不要把耗時操作放在主執行緒,會卡介面。

多執行緒:在同一時刻,一個CPU只能處理1條執行緒,但CPU可以在多條執行緒之間快速的切換,只要切換的足夠快,就造成了多執行緒一同執行的假象。

執行緒就像火車的一節車廂,程式則是火車。車廂(執行緒)離開火車(程式)是無法跑動的,而火車(程式)至少有一節車廂(主執行緒)。多執行緒可以看做多個車廂,它的出現是為了提高效率。
多執行緒是通過提高資源使用率來提高系統總體的效率。

我們運用多執行緒的目的是:將耗時的操作放在後臺執行!

多執行緒
多執行緒

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

執行緒的生命週期是:新建 - 就緒 - 執行 - 阻塞 - 死亡

下面分別闡述執行緒生命週期中的每一步

新建:例項化執行緒物件

就緒:向執行緒物件傳送start訊息,執行緒物件被加入可排程執行緒池等待CPU排程。

執行:CPU 負責排程可排程執行緒池中執行緒的執行。執行緒執行完成之前,狀態可能會在就緒和執行之間來回切換。就緒和執行之間的狀態變化由CPU負責,程式設計師不能干預。

阻塞:當滿足某個預定條件時,可以使用休眠或鎖,阻塞執行緒執行。sleepForTimeInterval(休眠指定時長),sleepUntilDate(休眠到指定日期),@synchronized(self):(互斥鎖)。

死亡:正常死亡,執行緒執行完畢。非正常死亡,當滿足某個條件後,線上程內部中止執行/在主執行緒中止執行緒物件

還有執行緒的exit和cancel
[NSThread exit]:一旦強行終止執行緒,後續的所有程式碼都不會被執行。
[thread cancel]取消:並不會直接取消執行緒,只是給執行緒物件新增 isCancelled 標記。

三、多執行緒的四種解決方案

多執行緒的四種解決方案分別是:pthread,NSThread,GCD, NSOperation。

pthread:運用C語言,是一套通用的API,可跨平臺Unix/Linux/Windows。執行緒的生命週期由程式設計師管理。
NSThread:物件導向,可直接操作執行緒物件。執行緒的生命週期由程式設計師管理。
GCD:代替NSThread,可以充分利用裝置的多核,自動管理執行緒生命週期。
NSOperation:底層是GCD,比GCD多了一些方法,更加物件導向,自動管理執行緒生命週期。

四、執行緒安全問題

當多個執行緒訪問同一塊資源時,很容易引發資料錯亂和資料安全問題。就好比幾個人在同一時修改同一個表格,造成資料的錯亂。

解決多執行緒安全問題的方法

方法一:互斥鎖(同步鎖)

@synchronized(鎖物件) {
    // 需要鎖定的程式碼
}複製程式碼

判斷的時候鎖物件要存在,如果程式碼中只有一個地方需要加鎖,大多都使用self作為鎖物件,這樣可以避免單獨再建立一個鎖物件。
加了互斥做的程式碼,當新執行緒訪問時,如果發現其他執行緒正在執行鎖定的程式碼,新執行緒就會進入休眠。

方法二:自旋鎖
加了自旋鎖,當新執行緒訪問程式碼時,如果發現有其他執行緒正在鎖定程式碼,新執行緒會用死迴圈的方式,一直等待鎖定的程式碼執行完成。相當於不停嘗試執行程式碼,比較消耗效能。
屬性修飾atomic本身就有一把自旋鎖。

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

nonatomic 非原子屬性,同一時間可以有很多執行緒讀和寫
atomic 原子屬性(執行緒安全),保證同一時間只有一個執行緒能夠寫入(但是同一個時間多個執行緒都可以取值),atomic 本身就有一把鎖(自旋鎖)

atomic:執行緒安全,需要消耗大量的資源
nonatomic:非執行緒安全,不過效率更高,一般使用nonatomic複製程式碼

五、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

六、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

七、NSOperation的理解與使用

No.1:NSOperation簡介

NSOperation是基於GCD之上的更高一層封裝,NSOperation需要配合NSOperationQueue來實現多執行緒。

NSOperation實現多執行緒的步驟如下:

1. 建立任務:先將需要執行的操作封裝到NSOperation物件中。
2. 建立佇列:建立NSOperationQueue3. 將任務加入到佇列中:將NSOperation物件新增到NSOperationQueue中。複製程式碼

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

  1. 使用子類NSInvocationOperation
  2. 使用子類NSBlockOperation
  3. 定義繼承自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];複製程式碼

注意:

  1. 非主佇列(其他佇列)可以實現序列或並行。
  2. 佇列NSOperationQueue有一個引數叫做最大併發數:maxConcurrentOperationCount。
  3. maxConcurrentOperationCount預設為-1,直接併發執行,所以加入到‘非佇列’中的任務預設就是併發,開啟多執行緒。
  4. 當maxConcurrentOperationCount為1時,則表示不開執行緒,也就是序列。
  5. 當maxConcurrentOperationCount大於1時,進行併發執行。
  6. 系統對最大併發數有一個限制,所以即使程式設計師把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)}複製程式碼

後記

本文所述的示例程式碼在這裡:WHMultiThreadDemo
推薦簡單又好用的分類集合:WHKit

github地址:github.com/remember17

相關文章