使用者等待的每一秒都是體驗的流失。無論用哪種語言,程式最終都會被編譯成機器碼,而機器碼是順序執行的,複雜的多步運算只能一步步來。要打破這個限制,有兩個切入點:
Apple 從 iPad 2 開始採用雙核 A5(iPhone 端則自 iPhone 4S 起),A7 更加入了協同處理器。如何把這些核心用好用滿,值得認真思考。
本文的骨架:
早在單核時代就有多執行緒,當時的目的幾乎只是迴避阻塞:UI 操作做完後使用者不再干涉,剩下的排入佇列,CPU 空了就跑,不影響使用者繼續操作其他介面。運算能力其實沒有提升。
到了多核時代,「並行運算」才真正被拿出來談。下圖展示一個含 8 個步驟的任務,在一顆雙核 CPU 上建立 4 個執行緒的情況:同一核心上的兩個執行緒交錯推進(並發),兩個核心之間則真正同時計算(並行)。單看一個核心,多執行緒只解決了不順暢的問題;跨核心的並行才是效率提升的來源。

好消息是:任務被分派到幾個核心完全由系統調度,開發者不必關心硬體細節。真正需要操心的是執行緒之間的依賴關係——若某件事必須在另一件完成後才能做,順序錯了程式就會出問題。
每個進程啟動時都會有一條主執行緒(UI 執行緒),它是其他執行緒的父執行緒。由於子執行緒不在 Cocoa Touch 的管理範圍內,只有主執行緒能更新 UI(新版本即使僥倖成功也不建議)。
iOS 提供三種主流寫法,出現順序越晚的通常越好用:
做過 .NET 的人會發現這三者分別對應多執行緒、執行緒池與非同步呼叫。
兩種啟動方式:
// 方式一:先建物件再 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 的問題在這裡暴露得很清楚:控制執行順序只能靠休眠這種笨辦法;每跑一次迴圈就建立一條新執行緒,而建立執行緒本身開銷不低。這些正是後兩種方案要解決的。
Apple 把常見場景包成了 NSObject 的分類方法(底層仍是 NSThread),簡單情境直接用即可:
performSelectorInBackground:withObject::在背景開一條執行緒執行。performSelector:onThread:withObject:waitUntilDone::在指定執行緒執行。performSelectorOnMainThread:withObject:waitUntilDone::在主執行緒執行。把一個 NSOperation 放進 NSOperationQueue,隊列會自行開啟執行緒並依序執行。它最大的兩項能力,是限制同時存在的執行緒數量與描述操作之間的依賴。
NSOperation 是抽象類,實務上用兩個子類:NSInvocationOperation 與 NSBlockOperation。兩者本質無異,但 Block 版本寫起來更輕巧。
NSInvocationOperation *operation =
[[NSInvocationOperation alloc] initWithTarget:self
selector:@selector(loadImage)
object:nil];
// 直接呼叫 start 會在主執行緒執行,實務上不要這麼做
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperation:operation]; // 加入隊列後才會開新執行緒
-(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 版本,核心程式碼乾淨許多,而且一次解決了三個痛點:
addOperationWithBlock:,不用再包一層 KCImageData。每個 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(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 會怎樣?

按鈕點不動了。因為所有下載都被推到主執行緒上同步執行,主執行緒被堵死,圖片最後一次全部出現。歸納三條結論:
dispatch_apply():重複執行某任務,本身無法非同步(想避免阻塞可用 dispatch_async 包一層)。dispatch_once():整個生命週期只執行一次,單例設計的標準做法。dispatch_time():延遲執行。dispatch_barrier_async():屏障任務,會等隊列中既有任務全部完成後才執行,且後續加入的任務必須等它結束。可借此控制順序。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,於是拿到同一張。解法是讓這段「讀取 + 修改」成為不可打斷的臨界區。
把爭用資源的讀寫包在 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:。
選一個物件作為同步標的(通常用 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 的信號量(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 遵循 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,任何人都進不來。

提示:除非必要,盡量別用鎖。多執行緒的目的是提升效率,而鎖本質上讓一段程式碼回到單一執行緒執行,反而可能拖慢整體。
performSelectorOnMainThread:、[[NSOperationQueue mainQueue] addOperationWithBlock:]、dispatch_sync(dispatch_get_main_queue(), ...)。[NSThread currentThread] 取得當前執行緒,用 sleepForTimeInterval: 讓它休眠。