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

iOS 多執行緒實戰:NSThread、NSOperation 與 GCD 全對比

編輯:iOS 開發綜合

為什麼需要多執行緒

使用者等待的每一秒都是體驗的流失。無論用哪種語言,程式最終都會被編譯成機器碼,而機器碼是順序執行的,複雜的多步運算只能一步步來。要打破這個限制,有兩個切入點:

  • 單核處理器:把步驟分散到不同執行緒。使用者完成 UI 操作後,後續任務在別的執行緒等著,CPU 一空閒就接著跑,而使用者早已去做下一件事。這解決的是「阻塞」,不是「效能」。
  • 多核處理器:除了不阻塞,同一個操作剩下的工作還能分散到多個核心同時計算,真正提升吞吐。前提是任務之間沒有順序依賴。

Apple 從 iPad 2 開始採用雙核 A5(iPhone 端則自 iPhone 4S 起),A7 更加入了協同處理器。如何把這些核心用好用滿,值得認真思考。

本文的骨架:

  1. NSThread:輕量、直觀,但生命週期自理
  2. NSOperation / NSOperationQueue:能控制數量與依賴
  3. GCD:抽象層最高,對多核最友善
  4. 執行緒同步:NSLock、@synchronized、GCD 信號量、NSCondition

一、並發與並行的分別

早在單核時代就有多執行緒,當時的目的幾乎只是迴避阻塞:UI 操作做完後使用者不再干涉,剩下的排入佇列,CPU 空了就跑,不影響使用者繼續操作其他介面。運算能力其實沒有提升。

到了多核時代,「並行運算」才真正被拿出來談。下圖展示一個含 8 個步驟的任務,在一顆雙核 CPU 上建立 4 個執行緒的情況:同一核心上的兩個執行緒交錯推進(並發),兩個核心之間則真正同時計算(並行)。單看一個核心,多執行緒只解決了不順暢的問題;跨核心的並行才是效率提升的來源。

好消息是:任務被分派到幾個核心完全由系統調度,開發者不必關心硬體細節。真正需要操心的是執行緒之間的依賴關係——若某件事必須在另一件完成後才能做,順序錯了程式就會出問題。

二、iOS 中的多執行緒

每個進程啟動時都會有一條主執行緒(UI 執行緒),它是其他執行緒的父執行緒。由於子執行緒不在 Cocoa Touch 的管理範圍內,只有主執行緒能更新 UI(新版本即使僥倖成功也不建議)。

iOS 提供三種主流寫法,出現順序越晚的通常越好用:

  1. NSThread:最貼近執行緒本身。
  2. NSOperation:物件導向包裝,類似 .NET 的執行緒池。
  3. GCD:Apple 目前最推薦,充分調用多核效能。

做過 .NET 的人會發現這三者分別對應多執行緒、執行緒池與非同步呼叫。

三、NSThread

兩種啟動方式:

// 方式一:先建物件再 start
NSThread *thread = [[NSThread alloc] initWithTarget:self
                                           selector:@selector(loadImage)
                                             object:nil];
[thread start];

// 方式二:直接 detach 一個新執行緒
[NSThread detachNewThreadSelector:@selector(loadImage)
                          toTarget:self
                        withObject:nil];

注意:start 只是把執行緒放進就緒狀態,不代表立刻執行,實際時機由系統決定。

解決阻塞:非同步下載圖片

-(void)loadImage{
    NSData *data = [self requestData];
    // 只有主執行緒能更新 UI;waitUntilDone 決定是否等它做完
    [self performSelectorOnMainThread:@selector(updateImage:)
                          withObject:data
                       waitUntilDone:YES];
}

-(NSData *)requestData{
    NSURL *url = [NSURL URLWithString:@"https://example.com/big.png"];
    return [NSData dataWithContentsOfURL:url];
}

按下按鈕後啟動一條新執行緒去抓圖,抓完再切回主執行緒更新畫面。整個等待過程中 UI 完全可操作,這就是多執行緒最直接的價值。

多執行緒並發與「只能傳一個參數」的限制

無論是 detachNewThreadSelector、initWithTarget 還是 performSelectorOnMainThread,參數都只有一個。要同時傳索引與圖片資料,就得自己包一個物件:

@interface KCImageData : NSObject
@property (nonatomic, assign) int index;
@property (nonatomic, strong) NSData *data;
@end
-(void)loadImage:(NSNumber *)index{
    int i = [index intValue];
    KCImageData *imageData = [[KCImageData alloc] init];
    imageData.index = i;
    imageData.data = [self requestData:i];
    NSThread *thread = [[NSThread alloc] initWithTarget:self
                                              selector:@selector(updateImage:)
                                                object:imageData];
    thread.name = [NSString stringWithFormat:@"Thread-%i", i];
    [thread start];
}

-(void)updateImage:(KCImageData *)imageData{
    UIImageView *imageView = _imageViews[imageData.index];
    imageView.image = [UIImage imageWithData:imageData.data];
}

可以觀察到:圖片並沒有依序載入。原因有兩個——執行緒雖依序啟動,實際執行順序由 CPU 調度決定;各條執行緒遭遇的網路狀況也不盡相同。網路無能為力,但優先級可以調:

thread.threadPriority = 1.0;   // 範圍 0~1,預設 0.5,越大越優先

提高優先級只是增加「早點被載入」的機率,並非保證。

執行緒狀態與休眠

想讓最後一張圖必定先出現?讓其他執行緒先睡兩秒:

-(NSData *)requestData:(int)index{
    if (index != ROW_COUNT * COLUMN_COUNT - 1) {
        [NSThread sleepForTimeInterval:2.0];
    }
    NSURL *url = [NSURL URLWithString:_imageNames[index]];
    return [NSData dataWithContentsOfURL:url];
}

執行緒狀態有三種:isExecuting、isFinished、isCancelled。取消狀態可以由外部干預——呼叫 cancel 即可,但要注意:主執行緒只能「標記」取消,無法真正中止執行緒;要中止必須在該執行緒內部呼叫 +[NSThread exit]。

-(void)stopAllThreads{
    for (NSThread *thread in _threads) {
        [thread cancel];
    }
}

-(void)loadImage:(NSNumber *)index{
    if ([[NSThread currentThread] isCancelled]) {
        [NSThread exit];            // 真正退出必須在執行緒自己身上做
        return;
    }
    // ... 下載與更新
}

NSThread 的問題在這裡暴露得很清楚:控制執行順序只能靠休眠這種笨辦法;每跑一次迴圈就建立一條新執行緒,而建立執行緒本身開銷不低。這些正是後兩種方案要解決的。

補充:NSObject 的分類擴充

Apple 把常見場景包成了 NSObject 的分類方法(底層仍是 NSThread),簡單情境直接用即可:

  • performSelectorInBackground:withObject::在背景開一條執行緒執行。
  • performSelector:onThread:withObject:waitUntilDone::在指定執行緒執行。
  • performSelectorOnMainThread:withObject:waitUntilDone::在主執行緒執行。

四、NSOperation 與 NSOperationQueue

把一個 NSOperation 放進 NSOperationQueue,隊列會自行開啟執行緒並依序執行。它最大的兩項能力,是限制同時存在的執行緒數量與描述操作之間的依賴。

NSOperation 是抽象類,實務上用兩個子類:NSInvocationOperation 與 NSBlockOperation。兩者本質無異,但 Block 版本寫起來更輕巧。

NSInvocationOperation

NSInvocationOperation *operation =
    [[NSInvocationOperation alloc] initWithTarget:self
                                         selector:@selector(loadImage)
                                           object:nil];
// 直接呼叫 start 會在主執行緒執行,實務上不要這麼做
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperation:operation];     // 加入隊列後才會開新執行緒

NSBlockOperation

-(void)loadImageWithMultiThread{
    int count = ROW_COUNT * COLUMN_COUNT;
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    queue.maxConcurrentOperationCount = 5;      // 最多 5 條執行緒

    for (int i = 0; i < count; ++i) {
        int index = i;
        NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
            NSData *data = [self requestData:index];
            [[NSOperationQueue mainQueue] addOperationWithBlock:^{
                [self updateImageWithData:data andIndex:index];
            }];
        }];
        [queue addOperation:operation];
    }
}

相比 NSThread 版本,核心程式碼乾淨許多,而且一次解決了三個痛點:

  1. 不必為每個任務單獨定義方法,也沒有「只能傳一個參數」的束縛。
  2. 更新 UI 直接用主執行緒隊列的 addOperationWithBlock:,不用再包一層 KCImageData。
  3. maxConcurrentOperationCount 能有效抑制執行緒數量,執行時你會看到圖片大致以五張一批的方式載入。

用依賴關係控制順序

每個 NSOperation 都能宣告依賴。若 A 依賴 B,隊列會先跑 B 再跑 A。想讓最後一張圖優先載入,讓其他操作全部依賴它即可:

-(void)loadImageWithMultiThread{
    int count = ROW_COUNT * COLUMN_COUNT;
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    queue.maxConcurrentOperationCount = 5;

    NSBlockOperation *last = [NSBlockOperation blockOperationWithBlock:^{
        [self loadImage:@(count - 1)];
    }];

    for (int i = 0; i < count - 1; ++i) {
        NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
            [self loadImage:@(i)];
        }];
        [operation addDependency:last];      // 其餘全部等最後一個先跑
        [queue addOperation:operation];
    }
    [queue addOperation:last];
}

最後加入隊列的操作反而第一個執行。依賴可以串成一條鏈(A→B→C),但絕對不能形成循環依賴,否則永遠不會執行。

五、GCD

GCD(Grand Central Dispatch)是一套以 C 語言實作的多執行緒機制,也是目前 Apple 官方推薦的方案。它抽象層最高、寫法最直,但完全面向過程而非物件。熟悉的 C# 非同步呼叫的人會覺得很親切。

GCD 同樣有一個統一管理的隊列,但分成兩類:

  • 串行隊列:只有一條執行緒,任務依加入順序逐個執行。
  • 並發隊列:多條執行緒,任務進來後被分配到可用核心,同時保證先進來的先處理。

此外還有一條特殊的主隊列,用於在主執行緒上跑任務。

串行隊列

// 建立串行隊列
dispatch_queue_t serialQueue = dispatch_queue_create("com.example.serial", DISPATCH_QUEUE_SERIAL);

for (int i = 0; i < count; ++i) {
    dispatch_async(serialQueue, ^{
        NSData *data = [self requestData:i];
        dispatch_async(dispatch_get_main_queue(), ^{
            [self updateImageWithData:data andIndex:i];
        });
    });
}

只有一條執行緒,因此圖片嚴格依序出現。更新 UI 用的 dispatch_get_main_queue(),本質與前兩種做法相同。

並發隊列

建立方式相同,把旗標換成 DISPATCH_QUEUE_CONCURRENT;實務上更常直接取用全域並發隊列:

-(void)loadImageWithMultiThread{
    int count = ROW_COUNT * COLUMN_COUNT;
    // 第一個參數是優先級,第二個參數目前無用,傳 0
    dispatch_queue_t globalQueue =
        dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    for (int i = 0; i < count; ++i) {
        dispatch_async(globalQueue, ^{
            NSData *data = [self requestData:i];
            dispatch_async(dispatch_get_main_queue(), ^{
                [self updateImageWithData:data andIndex:i];
            });
        });
    }
}

把 dispatch_async 換成 dispatch_sync 會怎樣?

按鈕點不動了。因為所有下載都被推到主執行緒上同步執行,主執行緒被堵死,圖片最後一次全部出現。歸納三條結論:

  • 一個任務是單執行緒還是多執行緒,取決於隊列類型 + 呼叫方式;只有並發隊列搭配非同步方法才會跑在多條執行緒上。
  • 串行隊列能保證順序;並發隊列的非同步呼叫無法保證順序。
  • UI 更新用同步方法(dispatch_sync 到主隊列),其他工作用非同步方法。

其他常用任務方法

  1. dispatch_apply():重複執行某任務,本身無法非同步(想避免阻塞可用 dispatch_async 包一層)。
  2. dispatch_once():整個生命週期只執行一次,單例設計的標準做法。
  3. dispatch_time():延遲執行。
  4. dispatch_barrier_async():屏障任務,會等隊列中既有任務全部完成後才執行,且後續加入的任務必須等它結束。可借此控制順序。
  5. dispatch_group_async() 搭配 dispatch_group_notify():任務分組,整組完成時收到通知。

六、執行緒同步

多條執行緒並發時,同一份資源可能被同時讀寫。經典例子是搶票:只剩一張票,同時有數千人在買。每個流程都會先檢查餘票再扣一,若 100 條執行緒同時通過檢查,最後餘票會變成 -99。這顯然不可接受。

iOS 常用的解法有 NSLock 與 @synchronized,原理相同,後者語法更省事。

下面用「9 個連結、15 條執行緒、每張只能取一次」重現這個問題:

-(NSData *)requestData:(int)index{
    NSString *name = nil;
    if (_imageNames.count > 0) {
        name = [_imageNames lastObject];
        [_imageNames removeObject:name];        // 讀取與移除之間有空隙
    }
    if (name) {
        return [NSData dataWithContentsOfURL:[NSURL URLWithString:name]];
    }
    return nil;
}

這個 bug 不一定每次都重現,取決於讀取與移除之間的時間差。原因很清楚:執行緒 A 取到連結還沒來得及刪除,執行緒 B 就進來了,而兩者取的都是 lastObject,於是拿到同一張。解法是讓這段「讀取 + 修改」成為不可打斷的臨界區。

NSLock

把爭用資源的讀寫包在 lock 與 unlock 之間即可。有個原則要牢記:鎖住的範圍只該包含資源的讀取與修改,不要把網路請求等耗時操作塞進去,否則其他執行緒只能乾等,多執行緒的意義蕩然無存。

另外,被爭用的資源建議宣告為 atomic 屬性。nonatomic 讀的是記憶體中已算好的結果,atomic 保證直接讀暫存器值,避免「一條執行緒正在改,另一條讀到舊值」的情況。

@interface KCMainViewController : UIViewController
@property (atomic, strong) NSMutableArray *imageNames;
@end
-(NSData *)requestData:(int)index{
    NSString *name = nil;
    [_lock lock];                               // 只鎖臨界區
    if (_imageNames.count > 0) {
        name = [_imageNames lastObject];
        [_imageNames removeObject:name];
    }
    [_lock unlock];

    if (name) {
        return [NSData dataWithContentsOfURL:[NSURL URLWithString:name]];
    }
    return nil;
}

想知道鎖是否已被佔用,可用 -tryLock(回傳 BOOL);想只在某段時間內嘗試加鎖,可用 -lockBeforeDate:。

@synchronized 程式碼塊

選一個物件作為同步標的(通常用 self),把臨界區放進去。進入時先檢查該物件是否已被佔用,是的話就等:

-(NSData *)requestData:(int)index{
    NSString *name = nil;
    @synchronized(self){
        if (_imageNames.count > 0) {
            name = [_imageNames lastObject];
            [_imageNames removeObject:name];
        }
    }
    if (name) {
        return [NSData dataWithContentsOfURL:[NSURL URLWithString:name]];
    }
    return nil;
}

延伸:用 GCD 信號量做同步

GCD 的信號量(dispatch_semaphore_t)走的是另一套思路。每次 signal 讓計數 +1,每次 wait 讓計數 -1;計數為 0 時 wait 會等到計數大於 0。把初始值設為 1,就得到一把互斥鎖:

// 建立時初始值為 1
_semaphore = dispatch_semaphore_create(1);

-(NSData *)requestData:(int)index{
    NSString *name = nil;
    dispatch_semaphore_wait(_semaphore, DISPATCH_TIME_FOREVER);
    if (_imageNames.count > 0) {
        name = [_imageNames lastObject];
        [_imageNames removeObject:name];
    }
    dispatch_semaphore_signal(_semaphore);

    if (name) {
        return [NSData dataWithContentsOfURL:[NSURL URLWithString:name]];
    }
    return nil;
}

延伸:用 NSCondition 做執行緒通信

執行緒的調度對程式是透明的,有時我們需要更精細的協調。NSCondition 遵循 NSLocking 協議,本身具備 lock/unlock,因此也能當同步鎖使用;但它真正的長處是協調執行順序:

  • -wait:讓當前執行緒進入等待並釋放鎖。
  • -signal:隨機喚醒一條等待中的執行緒。
  • -broadcast:喚醒所有等待中的執行緒。

這正好構成生產者—消費者模型:15 條執行緒負責載入圖片,但佇列裡 initially 一張都沒有,於是全部進入等待;每次「建立圖片連結」的生產者放入一筆資料並 signal 一條消費者,它就接著把圖載下來。

// 生產者
-(void)createImageName{
    [_condition lock];
    if (_imageNames.count > 0) {
        [_condition wait];                      // 沒東西可放就先等
    } else {
        [_imageNames addObject:[NSString stringWithFormat:@"https://example.com/%i.jpg", _currentIndex++]];
        [_condition signal];                    // 放好就喚醒一條消費者
    }
    [_condition unlock];
}

// 消費者
-(void)loadImage:(NSNumber *)index{
    int i = [index intValue];
    [_condition lock];
    if (_imageNames.count > 0) {
        [self loadAnUpdateImageWithIndex:i];
        [_condition broadcast];
    } else {
        [_condition wait];                      // 沒資源可消費就等
        [self loadAnUpdateImageWithIndex:i];    // 被喚醒後立刻處理
    }
    [_condition unlock];
}

這裡有個與 NSLock 截然不同的關鍵點:wait 會在等待期間釋放鎖,讓其他執行緒得以進入臨界區並同樣進入等待;而 NSLock 或 @synchronized 只要沒 unlock,任何人都進不來。

iOS 中其他常見的鎖

  • NSRecursiveLock:遞歸鎖。臨界區內若存在遞歸呼叫,普通鎖會自我死鎖;遞歸鎖允許同一執行緒重複取得,並記錄取得與釋放次數,兩者平衡時才真正釋放。
  • NSDistributedLock:分散式鎖,本質是互斥鎖,以檔案實作,可跨進程。
  • pthread_mutex_t:C 語言的同步鎖,用法與上述類似。

提示:除非必要,盡量別用鎖。多執行緒的目的是提升效率,而鎖本質上讓一段程式碼回到單一執行緒執行,反而可能拖慢整體。

七、重點回顧

  1. 任何方式建立的執行緒,啟動後都不保證立刻執行,時機由系統調度。
  2. UI 更新必須在主執行緒,且建議同步呼叫:performSelectorOnMainThread:、[[NSOperationQueue mainQueue] addOperationWithBlock:]、dispatch_sync(dispatch_get_main_queue(), ...)。
  3. NSThread 適合輕量任務,但難以控制順序,也無法控制總數(每次都得新建,無法重用)。
  4. 簡單情境優先用 NSObject 的分類方法,不必親手管理 NSThread。
  5. 用 [NSThread currentThread] 取得當前執行緒,用 sleepForTimeInterval: 讓它休眠。
  6. NSOperation 能控制執行緒總數與依賴關係。
  7. NSOperation 不要直接呼叫 start(會在主執行緒跑),務必放進 NSOperationQueue。
  8. NSBlockOperation 優於 NSInvocationOperation:程式碼更短,且天生沒有傳參問題。
  9. NSOperation 是 GCD 的物件導向封裝。任務有依賴關係或需要監聽完成狀態時優先選它,否則用 GCD。
  10. 串行隊列把任務放在單一(非主)執行緒,順序好控;並發隊列在多條執行緒上跑(前提是非同步),效率更高但順序較難掌握。
  11. 隊列類型與呼叫方式共同決定單執行緒還是多執行緒;並發隊列若用同步呼叫,會退化成在主執行緒執行。
  12. @synchronized 比 NSLock 簡潔,優先採用。
  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved