您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發基礎

超詳細:iOS 並發編程之 Operation Queues 完全指南

編輯:iOS 開發基礎

作者:@雷純鋒2011 授權本站轉載。

移動設備早已進入多核時代,而且核心數只會增加、不會減少。作為開發者,我們要做的是盡可能提高應用的並發性,把這些核心真正利用起來。

在 iOS 裡,提升並發性主要有三條路:Operation Queues、Dispatch Queues 和 Dispatch Sources。後兩者屬於 Grand Central Dispatch(以下簡稱 GCD)的範疇,將在後續文章中介紹,本文專講 Operation Queues。

內容比較多,建議先掃一眼目錄,建立宏觀印象:

  • 基本概念:術語 / 串行 vs 並發 / 同步 vs 異步 / 隊列 vs 線程
  • iOS 的並發編程模型
  • Operation Queues vs GCD
  • 關於 Operation 對象:並發與非並發 / NSInvocationOperation / NSBlockOperation
  • 自定義 Operation:主任務 / 響應取消 / 並發配置 / KVO 通知
  • 定制執行行為:依賴關係 / 隊列優先級 / 線程優先級 / Completion Block
  • 執行 Operation:入隊 / 手動執行 / 取消 / 等待 / 暫停與恢復

一、先把概念理清楚

本文所說的 Operation Queues,是 NSOperation 與 NSOperationQueue 的統稱。

三個基礎術語

  • 進程(process):一個正在運行中的可執行文件。每個進程擁有獨立的虛擬內存空間與系統資源(包括端口權限等),至少包含一條主線程和任意數量的輔助線程。主線程退出,進程即結束。
  • 線程(thread):一條獨立的代碼執行路徑,也就是代碼執行路徑的最小分支。iOS 中線程的底層實現基於 POSIX threads API,也就是常說的 pthreads。
  • 任務(task):我們需要執行的工作。它是個抽象概念,通俗地說就是一段代碼。

串行 vs 並發

本質區別在於「允許同時執行的任務數量」。串行是一次只能跑一個任務,前一個跑完才輪下一個;並發則允許多個任務同時推進。

同步 vs 異步

關鍵在於「是否等待操作完成」,也就是是否阻塞當前線程。同步會等結果回來才繼續往下走;異步則調用後立即返回,不等結果。

這兩組概念彼此正交,很容易被混為一談:串行/並發說的是「資源怎麼排布」,同步/異步說的是「當前線程要不要等」。串行隊列 + 異步、串行隊列 + 同步,都是合法且常見的組合。

隊列 vs 線程

iOS 中有兩種隊列:串行隊列一次執行一個任務,並發隊列允許同時執行多個。系統用這些隊列做任務調度,會根據調度需求與當前負載動態創建、銷毀線程,不需要我們手動管理。這正是「隊列」和「線程」的分界:你操作的是隊列,線程由系統代管。

二、iOS 的並發編程模型

在很多語言裡,提高並發性意味著自己創建一條或多條額外線程,並手動管理它們的生命周期——這本身就是件極具挑戰的事。更糟的是,最優線程數會隨系統負載與底層硬件動態變化,單個應用幾乎不可能算出一套永遠正確的多線程方案。再加上線程同步機制大幅提升了代碼複雜度,還不保證性能真的提升。

蘋果的方案換了個思路:不是讓你創建線程,而是讓你描述任務,剩下的交給系統。線程的創建與銷毀、多線程之間的同步,全部由系統在更低的層次上處理,效率遠高於手工管理。

所以請聽勸:珍愛生命,遠離線程。不過隊列也不是萬靈丹,以下三種情況仍然應該直接用線程:

  • 用線程以外的任何方式都無法實現你的特定任務;
  • 必須實時執行某個任務——隊列會盡快執行,但不保證實時性;
  • 你需要對後台任務有更可預測的行為控制。

三、Operation Queues vs GCD

簡單說,GCD 是蘋果基於 C 語言的多核編程方案,用於優化應用以支持多核處理器與其他對稱多處理系統;Operation Queues 則是建在 GCD 之上的面向對象封裝。

  • Operation Queues:相對 GCD 會多一點開銷,但換來的是強大得多的靈活性——可以给 operation 之間加依賴、可以取消正在執行的 operation、可以暫停與恢復整個 queue。
  • GCD:更輕量,按 FIFO 順序執行並發任務,調度完全交給系統。但短板也很明顯:想加依賴、想取消或暫停某個任務,會變得非常棘手。

四、關於 Operation 對象

我們用 NSOperation 類封裝需要執行的任務,一個 operation 就是它的一個具體實例。NSOperation 本身是抽象類,不能直接實例化,要麼自定義子類,要麼用系統預定義的 NSInvocationOperation 和 NSBlockOperation。

NSInvocationOperation:通過一個 object 加一個 selector 就能創建,非常動態。如果你手頭已經有一個現成方法,方法裡的代碼正好就是要執行的任務,那麼不改一行既有代碼,直接拿它的所屬對象和方法造一個 NSInvocationOperation 即可。

NSBlockOperation:可以並發執行一個或多個 block。只有關聯的所有 block 都跑完,這個 operation 才算完成——概念上有點像 dispatch_group。

所有 operation 都支持這些特性:

  • 建立依賴關係:只有被依賴的 operation 全部完成,本 operation 才能開始;
  • 設置可選的 completion block,在主任務完成時調用;
  • 通過 KVO 觀察執行狀態變化;
  • 設置優先級,影響 operation 之間的相對執行順序;
  • 支持取消,可以讓正在執行的 operation 停下來。

並發 vs 非並發 Operation

通常我們把 operation 加進 queue 來執行,但這不是唯一方式——也可以直接調 start,只是這種方式不保證異步。isConcurrent 的返回值標識的就是:相對於調用 start 的那條線程而言,這個 operation 是否異步執行。默認返回 NO,即會阻塞調用方。

想要自定義一個並發的 operation,就得自己寫代碼讓它異步跑起來:開新線程、調用系統的異步方法,或者任何能讓 start 執行後立刻返回的手段。

絕大多數情況下你都不需要並發的 operation。只要你始終通過 queue 來執行,就完全不必操心——queue 會自動為非並發的 operation 準備線程。只有當你要手動執行一個 operation、同時又希望它異步時,才值得去實現並發版本。

創建 NSInvocationOperation

@implementation OQCreateInvocationOperation

- (NSInvocationOperation *)invocationOperationWithData:(id)data {
    return [[NSInvocationOperation alloc] initWithTarget:self
                                              selector:@selector(myTaskMethod1:)
                                                object:data];
}

- (void)myTaskMethod1:(id)data {
    NSLog(@"Start executing %@ with data: %@, mainThread: %@, currentThread: %@",
          NSStringFromSelector(_cmd), data, [NSThread mainThread], [NSThread currentThread]);
    sleep(3);
    NSLog(@"Finish executing %@", NSStringFromSelector(_cmd));
}

@end

它靈活的地方在於可以根據上下文動態切換 selector。比如依據用戶輸入決定跑哪個方法:

- (NSInvocationOperation *)invocationOperationWithData:(id)data userInput:(NSString *)userInput {
    NSInvocationOperation *invocationOperation = [self invocationOperationWithData:data];
    if (userInput.length == 0) {
        invocationOperation.invocation.selector = @selector(myTaskMethod2:);
    }
    return invocationOperation;
}

- (void)myTaskMethod2:(id)data {
    NSLog(@"Start executing %@ with data: %@, mainThread: %@, currentThread: %@",
          NSStringFromSelector(_cmd), data, [NSThread mainThread], [NSThread currentThread]);
    sleep(3);
    NSLog(@"Finish executing %@", NSStringFromSelector(_cmd));
}

創建 NSBlockOperation

既然 GCD 主要就是用來調度 block 的,為什麼還需要 NSBlockOperation?通常有兩個場景:

  • 項目裡已經在用 Operation Queues,不想再引入 Dispatch Queues——NSBlockOperation 提供了面向對象的封裝;
  • 需要用到 Dispatch Queue 不具備的能力,比如設置依賴關係、用 KVO 觀察狀態變化。
@implementation OQCreateBlockOperation

- (NSBlockOperation *)blockOperation {
    NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"Start executing block1, mainThread: %@, currentThread: %@",
              [NSThread mainThread], [NSThread currentThread]);
        sleep(3);
        NSLog(@"Finish executing block1");
    }];

    [blockOperation addExecutionBlock:^{
        NSLog(@"Start executing block2, mainThread: %@, currentThread: %@",
              [NSThread mainThread], [NSThread currentThread]);
        sleep(3);
        NSLog(@"Finish executing block2");
    }];

    [blockOperation addExecutionBlock:^{
        NSLog(@"Start executing block3, mainThread: %@, currentThread: %@",
              [NSThread mainThread], [NSThread currentThread]);
        sleep(3);
        NSLog(@"Finish executing block3");
    }];

    return blockOperation;
}

@end

注意這三個 block 之間沒有任何順序約束,它們會並發執行。

五、自定義 Operation 對象

系統預定義的兩個子類不夠用時,就自己寫。可以自定義非並發和並發兩種,前者簡單得多。

非並發的 operation 只需要做兩件事:在 main 裡執行任務、能夠正常響應取消。依賴配置、KVO 通知這些髒活 NSOperation 已經替你幹了。並發版本則還要重寫一批方法。

執行主任務

最低限度,每個 operation 都應該實現:一個自定義初始化方法,以及 main 方法。初始化方法把對象置於已知狀態,main 裡放真正的任務。也可以額外實現 NSCoding 協議以支持歸檔。

@interface OQNonConcurrentOperation ()
@property (strong, nonatomic) id data;
@end

@implementation OQNonConcurrentOperation

- (id)initWithData:(id)data {
    self = [super init];
    if (self) {
        self.data = data;
    }
    return self;
}

/// 不支持取消操作
- (void)main {
    @try {
        NSLog(@"Start executing %@ with data: %@, mainThread: %@, currentThread: %@",
              NSStringFromSelector(_cmd), self.data, [NSThread mainThread], [NSThread currentThread]);
        sleep(3);
        NSLog(@"Finish executing %@", NSStringFromSelector(_cmd));
    }
    @catch (NSException *exception) {
        NSLog(@"Exception: %@", exception);
    }
}

@end

響應取消事件

一個 operation 一旦開始執行,會一直跑到完成或被取消。你可以在任意時刻取消它,甚至是在它還沒開始之前。

要讓自定義的 operation 支持取消,需要在代碼中定期檢查 isCancelled 的返回值,一旦為 YES 就立刻停止後續工作。蘋果官方說法是:isCancelled 本身非常輕量,高頻調用也不會帶來明顯的性能負擔。

通常需要在這幾個關鍵點檢查:

  • 真正開始執行任務之前;
  • 至少在每次循環中檢查一次;若單次循環本身就耗時較長,則需要更頻繁地檢查;
  • 任何相對容易中止的地方。

由此可以意識到一件重要的事:operation 支持取消,但不是立即取消——而是在你調用 cancel 之後的下一個檢查點才生效。

/// 支持取消操作
- (void)main {
    @try {
        if (self.isCancelled) return;
        NSLog(@"Start executing %@ with data: %@, mainThread: %@, currentThread: %@",
              NSStringFromSelector(_cmd), self.data, [NSThread mainThread], [NSThread currentThread]);
        for (NSUInteger i = 0; i < 3; i++) {
            if (self.isCancelled) return;
            sleep(1);
            NSLog(@"Loop %@", @(i + 1));
        }
        NSLog(@"Finish executing %@", NSStringFromSelector(_cmd));
    }
    @catch (NSException *exception) {
        NSLog(@"Exception: %@", exception);
    }
}

配置並發執行的 Operation

默認情況下 operation 是同步的,即在調用 start 的那條線程裡執行任務。與 queue 搭配時,queue 會為非並發的 operation 提供線程,所以大部分 operation 依然是異步的。但如果你想手動執行、又要它異步,就需要額外配置。可能需要重寫的方法有:

  • start(必須):所有並發 operation 都要重寫它,替換掉 NSOperation 的默認實現。它是 operation 的起點,在這裡配置任務執行的線程與執行環境。千萬不要調用父類的實現。
  • main(可選):通常用來放具體任務。即使可以直接在 start 裡寫任務,用 main 分離出來能讓「設置代碼」與「任務代碼」互不干擾,結構更清晰。
  • isExecuting / isFinished(必須):並發 operation 要負責維護自己的執行狀態,並向外界報告。這兩個值變化時必須發出相應的 KVO 通知。
  • isConcurrent(必須):重寫並返回 YES。
@implementation OQConcurrentOperation

@synthesize executing = _executing;
@synthesize finished  = _finished;

- (id)init {
    self = [super init];
    if (self) {
        _executing = NO;
        _finished  = NO;
    }
    return self;
}

- (BOOL)isConcurrent { return YES; }
- (BOOL)isExecuting  { return _executing; }
- (BOOL)isFinished   { return _finished; }

@end

這段代碼看著簡單,但有兩個細節值得琢磨。第一,用 @synthesize 手動合成了 _executing 和 _finished 兩個成員,再在重寫的 getter 中返回。第二,查看 NSOperation 的頭文件會發現 executing 和 finished 都被聲明為 readonly——子類無法通過 setter 自動觸發 KVO,這就是為什麼接下來必須手動發通知。

- (void)start {
    if (self.isCancelled) {
        [self willChangeValueForKey:@"isFinished"];
        _finished = YES;
        [self didChangeValueForKey:@"isFinished"];
        return;
    }

    [self willChangeValueForKey:@"isExecuting"];
    [NSThread detachNewThreadSelector:@selector(main) toTarget:self withObject:nil];
    _executing = YES;
    [self didChangeValueForKey:@"isExecuting"];
}

這裡最關鍵的一步是為 main 分離了一條新線程——這正是「並發」的由來。此外,正式開工前先檢查 isCancelled,已取消就直接收尾返回。

- (void)main {
    @try {
        NSLog(@"Start executing %@, mainThread: %@, currentThread: %@",
              NSStringFromSelector(_cmd), [NSThread mainThread], [NSThread currentThread]);
        sleep(3);

        [self willChangeValueForKey:@"isExecuting"];
        _executing = NO;
        [self didChangeValueForKey:@"isExecuting"];

        [self willChangeValueForKey:@"isFinished"];
        _finished  = YES;
        [self didChangeValueForKey:@"isFinished"];

        NSLog(@"Finish executing %@", NSStringFromSelector(_cmd));
    }
    @catch (NSException *exception) {
        NSLog(@"Exception: %@", exception);
    }
}

這裡有個極易踩的坑:即使一個 operation 被 cancel 掉了,你仍然必須手動觸發 isFinished 的 KVO 通知。原因在於,當 operation A 依賴 B 時,A 會觀察 B 的 isFinished;只有 B 的 isFinished 變為 YES,A 才能開始。如果自定義的 B 被取消卻沒發出通知,那麼所有依賴它的 operation 都將永遠等下去。

維護 KVO 通知

NSOperation 支持 KVO 的 key path 有:

  • isCancelled / isConcurrent / isExecuting / isFinished
  • isReady
  • dependencies
  • queuePriority
  • completionBlock

如果你只重寫 main,這些通知都由基類照看。但一旦重寫了 start 或做了大量定制,就得自己保證這些 key path 仍然合規。其中 isExecuting 和 isFinished 最受重寫 start 的影響,需要重點關注。

六、定制 Operation 的執行行為

創建完 operation、入隊之前,可以調它的執行行為。以下定制對所有 operation 通用,與是否自定義子類無關。

配置依賴關係

- (void)addDependency:(NSOperation *)op;
- (void)removeDependency:(NSOperation *)op;

第一個添加依賴,第二個移除。注意 addDependency: 建立的依賴是單向的:[A addDependency:B]; 表示 A 依賴 B,B 並不依賴 A。

依賴關係並不局限於同一個 queue 內部。這兩個方法定義在 NSOperation 上,說明依賴由 operation 自己管理,與它被放進哪個 queue 無關。所以完全可以先配好依賴,再把這些 operation 分散添加到不同的 queue 裡。

但有一條絕對不要犯的錯:不要形成循環依賴,否則這幾個 operation 誰也不會執行。

另外,請在手動執行或入隊之前配好依賴——之後再添加的依賴可能已經失效。

修改 Operation 在隊列中的優先級

入隊的 operation,決定執行順序的第一要素是 isReady 狀態,其次才是隊列優先級。默認新建的 operation 優先級是 normal,可以通過 setQueuePriority: 調高或調低。

隊列優先級只在同一個 queue 內部生效,跨 queue 不比較。它與依賴關係的區別在於:優先級只在所有 isReady 為 YES 的 operation 之間決定先後。若一個高優先級的 operation isReady 為 NO,而一個低優先級的 isReady 為 YES,那麼後者反而先跑。

修改執行任務線程的優先級

從 iOS 4.0 起可以設置 operation 所在线程的優先級。線程策略由內核管理,但一般來說高優先級線程能獲得更多運行機會。取值範圍 0.0 到 1.0,默認 0.5,通過 setThreadPriority: 設置。

注意:只能在執行或入隊之前設置。operation 開始執行時,NSOperation 默認的 start 會用這個值去調整當前線程優先級。而且它只影響 main 所在线程——包括 completion block 在內的其他代碼仍以默認優先級執行。所以自定義並發 operation 時,需要自己在 start 裡動手調整。

設置 Completion Block

從 iOS 4.0 起,operation 可以在主任務完成時回調一個 completion block。適合用來做主任務之外的收尾工作,比如通知客戶「我跑完了」,或者生成最終的 KVO 通知。設置方式很簡單:setCompletionBlock:。

兩個注意點:operation 被取消時 completion block 依然會執行,所以裡面要先查一下 isCancelled;另外也無法保證它一定在主線程被調用——理論上它與觸發 isFinished KVO 通知的線程一致。若需要更新 UI,請在 block 內用 GCD 切回主線程。

七、執行 Operation

兩種方式:加入 operation queue 讓系統代管,或者直接調 start 手動執行。

加入 Operation Queue

這是推薦做法。NSOperationQueue 的實例創建起來毫無門檻:

NSOperationQueue *operationQueue = [[NSOperationQueue alloc] init];

技術上你可以創建任意多個 queue,但 queue 數量多並不意味著能同時跑更多 operation——真正的並發上限由系統根據可用核心數與負載動態決定。添加方式有三種:

  • addOperation::添加一個 operation;
  • addOperations:waitUntilFinished::批量添加;
  • addOperationWithBlock::直接添加一個 block,省去手動包裝 NSBlockOperation。

多數情況下 operation 入隊後不久就會執行,但以下原因會造成延遲:所依賴的 operation 尚未完成、queue 處於暫停狀態、或者已達到最大並發數。

@implementation OQUseOperationQueue

- (void)executeOperationUsingOperationQueue {
    NSOperationQueue *operationQueue = [[NSOperationQueue alloc] init];

    NSInvocationOperation *invocationOperation =
        [[NSInvocationOperation alloc] initWithTarget:self
                                            selector:@selector(taskMethod)
                                              object:nil];
    [operationQueue addOperation:invocationOperation];

    NSBlockOperation *blockOperation1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"Start executing blockOperation1, mainThread: %@, currentThread: %@",
              [NSThread mainThread], [NSThread currentThread]);
        sleep(3);
        NSLog(@"Finish executing blockOperation1");
    }];

    NSBlockOperation *blockOperation2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"Start executing blockOperation2, mainThread: %@, currentThread: %@",
              [NSThread mainThread], [NSThread currentThread]);
        sleep(3);
        NSLog(@"Finish executing blockOperation2");
    }];

    [operationQueue addOperations:@[blockOperation1, blockOperation2] waitUntilFinished:NO];

    [operationQueue addOperationWithBlock:^{
        NSLog(@"Start executing block, mainThread: %@, currentThread: %@",
              [NSThread mainThread], [NSThread currentThread]);
        sleep(3);
        NSLog(@"Finish executing block");
    }];

    [operationQueue waitUntilAllOperationsAreFinished];
}

- (void)taskMethod {
    NSLog(@"Start executing %@, mainThread: %@, currentThread: %@",
          NSStringFromSelector(_cmd), [NSThread mainThread], [NSThread currentThread]);
    sleep(3);
    NSLog(@"Finish executing %@", NSStringFromSelector(_cmd));
}

@end

入隊之後就不要再改這個 operation 了。它隨時可能被系統拉去執行,此時再修改依賴關係或所包含的數據,後果不可預期。

NSOperationQueue 天生為並發設計,但也可以強制它一次只跑一個:把 maxConcurrentOperationCount 設為 1 即可。

[operationQueue setMaxConcurrentOperationCount:1];

不過要注意,即便如此,執行順序仍受 isReady 狀態與隊列優先級影響,並非嚴格 FIFO。這與串行 dispatch queue 有本質區別——後者的順序永遠是 FIFO。如果順序對你至關重要,請在入隊之前用依賴關係把它鎖死。

手動執行 Operation

原理上很簡單:調 start 就行。但嚴謹一點,在調用之前應該做幾項檢查:isReady 是否為 YES(取決於依賴是否完成)、isCancelled 是否已為 YES(若是,就別白費開銷去啟動它)。

另外,永遠通過 start 而不是 main 去啟動。因為默認的 start 會先做安全檢查(比如是否已取消),並生成 isExecuting、isFinished 等必要的 KVO 通知——而這些通知正是依賴機制得以正常運作的前提。直接調 main 會繞過這一切。

若你的 operation 是並發的,還應檢查一下 isConcurrent。為 NO 時,可以考慮直接在當前線程同步執行,或者另開一條線程讓它異步跑。

@implementation OQManualExecuteOperation

- (BOOL)manualPerformOperation:(NSOperation *)operation {
    BOOL ranIt = NO;
    if (operation.isCancelled) {
        ranIt = YES;
    } else if (operation.isReady) {
        if (!operation.isConcurrent) {
            [operation start];
        } else {
            [NSThread detachNewThreadSelector:@selector(start) toTarget:operation withObject:nil];
        }
        ranIt = YES;
    }
    return ranIt;
}

@end

取消 Operation

原則上,operation 一旦入隊,所有權就歸 queue 所有,無法被移除。讓它「出隊」的唯一方式是取消:調 operation 的 cancel,或調 queue 的 cancelAllOperations。

取消後該 operation 的 isFinished 也會變成 YES,這正是設計上的巧思——依賴它的 operation 能收到 KVO 通知,從而順利解除依賴、正常執行。

等待執行完成

為了性能,我們應該盡可能異步執行所有 operation,讓應用在等待的同時仍能響應用戶操作。當然,你也可以調 waitUntilFinished 阻塞當前線程直到該 operation 完成——方便是方便,但代價是引入更多串行、削弱並發、降低響應性。

堅決避免在主線程同步等待 operation。阻塞只應用於輔助線程或其他 operation 內部。

同理,[queue waitUntilAllOperationsAreFinished] 可以等整個 queue 清空。要注意的是,等待期間其他線程仍可繼續往這個 queue 裡添加 operation,從而延長你的等待時間。

暫停與恢復 Operation Queue

調用 queue 的 setSuspended: 可以暫停與恢復。但「暫停」並不會讓正在執行的 operation 停下,它只是停止調度新的 operation 進來。而且你無法單獨暫停某個 operation——除非直接把它 cancel 掉。

總結

iOS 的並發模型鼓勵你把注意力放在「任務」而不是「線程」上:定義好要調度的單元,剩下的交給系統。

一般情況下也完全不必自定義並發的 operation——只要走 queue,queue 會自動為非並發的 operation 分配線程。Operation Queues 是 GCD 的面向對象封裝,在依賴關係、隊列優先級、線程優先級這幾個維度上提供了細粒度控制,是處理複雜任務調度時的首選。

參考鏈接

版權聲明:我已將本文在微信公眾平台的發表權「獨家代理」給 iOS 開發(iOSDevTips)微信公眾號。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved