
英文原文:The GCD Handbook,譯者:walkingway(微博)
Grand Central Dispatch,也就是大家熟悉的 GCD,是一件非常強力的武器。它把隊列、信號量這些底層工具交到你手上,讓你能自行組裝出想要的多執行緒行為。遺憾的是,這套 C 語言 API 相當不友善,想用低階積木拼出高階抽象(類似 NSOperation 那種)也不容易。這篇文章要談的,就是如何把 GCD 的積木組出高階行為。
這大概是 GCD 最簡單的用法:把耗時任務丟到後台執行緒,做完再回主線程,因為 UIKit 的操作只能在主線程進行。
本文用 doSomeExpensiveWork() 代表一個長時間運行、最終會回傳結果的任務。基本套路是:
let defaultPriority = DISPATCH_QUEUE_PRIORITY_DEFAULT let backgroundQueue = dispatch_get_global_queue(defaultPriority, 0) dispatch_async(backgroundQueue, { let result = doSomeExpensiveWork() dispatch_async(dispatch_get_main_queue(), { //use `result` somehow }) })實務上除了 DISPATCH_QUEUE_PRIORITY_DEFAULT,其他優先級幾乎用不到。dispatch_get_global_queue() 會回傳一個能支撐數百條執行緒的隊列。若你總是需要在專屬的後台隊列上跑重活,可以用 dispatch_queue_create 自建,它帶兩個參數:隊列名稱,以及串行還是並發。
要特別注意 dispatch_async 與 dispatch_sync 的差別。async 會在 block 開始執行前就立刻返回,sync 則會等 block 跑完才返回。內部呼叫可以用 sync(反正不在意何時返回),但對外一定要用 async,否則主線程會被整條卡住。
dispatch_once 是建立單例的經典做法。不過在 Swift 裡已有更簡潔的語法,這裡只列 OC 版本:
+ (instancetype) sharedInstance { static dispatch_once_t onceToken; static id sharedInstance; dispatch_once(&onceToken, ^{ sharedInstance = [[self alloc] init]; }); return sharedInstance; }從這裡開始變得有趣。我們可以用信號量把一條執行緒阻塞任意長的時間,直到另一條執行緒發出信號。信號量與 GCD 其他部分一樣是執行緒安全的,而且任何位置都能觸發。
當你手上有一個必須同步執行、卻又無法修改的異步 API 時,信號量就派上用場:
// on a background queue dispatch_semaphore_t semaphore = dispatch_semaphore_create(0) doSomeExpensiveWorkAsynchronously(completionBlock: { dispatch_semaphore_signal(semaphore) }) dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER) //the expensive asynchronous work is now donedispatch_semaphore_wait 會把執行緒卡住,直到 dispatch_semaphore_signal 被呼叫。也就是說 signal 一定要從別的執行緒發出,因為當前執行緒已被完全阻塞;更進一步,wait 絕對不能在主線程呼叫,只能用在後台執行緒。
wait 可以帶超時參數,但我通常直接用 DISPATCH_TIME_FOREVER。
既然已經有 completion block,為什麼還想攤平?因為方便。一個典型場景是:要依序執行一組異步任務,前一個沒完成就不能動下一個。把這個想法抽象成 AsyncSerialWorker:
typealias DoneBlock = () -> () typealias WorkBlock = (DoneBlock) -> () class AsyncSerialWorker { private let serialQueue = dispatch_queue_create("com.khanlou.serial.queue", DISPATCH_QUEUE_SERIAL) func enqueueWork(work: WorkBlock) { dispatch_async(serialQueue) { let semaphore = dispatch_semaphore_create(0) work({ dispatch_semaphore_signal(semaphore) }) dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER) } } }這個簡短的類建立了一條串行隊列,讓你把入隊的 work 包在 block 裡。WorkBlock 需要一個 DoneBlock 參數,它在該項工作結束時被執行;我們把 DoneBlock 設為 { dispatch_semaphore_signal(semaphore) },藉此釋放信號量,讓串行隊列繼續往下走。
譯者補充:既然用了 DISPATCH_QUEUE_SERIAL,隊列中的 work 不是本來就先進先出嗎?確實如此,但若把 work 想成一個耗時的網路操作,其內部又 dispatch_async 到別的執行緒去跑,那麼每次走到 work 就立刻返回了,結果可能還沒回來。要保證前一個 work 拿到結果後才執行下一個,就需要 semaphore。打開 Playground 試試:
import UIKit import XCPlayground typealias DoneBlock = () -> () typealias WorkBlock = (DoneBlock) -> () class AsyncSerialWorker { private let serialQueue = dispatch_queue_create("com.khanlou.serial.queue", DISPATCH_QUEUE_SERIAL) func enqueueWork(work: WorkBlock) { dispatch_async(serialQueue) { let semaphore = dispatch_semaphore_create(0) work({ dispatch_semaphore_signal(semaphore) }) dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER) } } } let a = AsyncSerialWorker() for i in 1...5 { a.enqueueWork { doneBlock in dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) { sleep(arc4random_uniform(4)+1) print(i) doneBlock() } } } XCPlaygroundPage.currentPage.needsIndefiniteExecution = true此時輸出是 1、2、3、4、5;把信號量相關程式碼註解掉,順序就亂了。
dispatch_semaphore_create(0) 這裡傳 0,是因為我們要讓兩個執行緒協調同一個事件;它內部其實維護著一個計數器。
上面的例子把信號量當成一個單純的旗標,但它也可以充當有限資源的計數器。若想限制某類資源的同時使用量:
class LimitedWorker { private let concurrentQueue = dispatch_queue_create("com.khanlou.concurrent.queue", DISPATCH_QUEUE_CONCURRENT) private let semaphore: dispatch_semaphore_t init(limit: Int) { semaphore = dispatch_semaphore_create(limit) } func enqueueWork(work: () -> ()) { dispatch_async(concurrentQueue) { dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER) work() dispatch_semaphore_signal(semaphore) } } }這個例子出自蘋果官方的多執行緒編程指南,官方的說明是:建立信號量時可以指定資源的可用數量,這個 long 型計數在初始化時傳入。每次 dispatch_semaphore_wait 都會消耗一次可用數,若結果為負,函數會請內核阻斷你的執行緒;相對地,dispatch_semaphore_signal 每次都會把可用數加一,表示已釋放資源,若有任務正在等待,系統會從等待隊列中解鎖一個去執行。
效果有點像 NSOperationQueue 的 maxConcurrentOperationCount。如果你用的是原生 GCD 隊列而不是 NSOperationQueue,就能靠信號量來限制並發數。
值得注意的是,每次呼叫 enqueueWork 都會把 work 丟進並發隊列,隊列收到就立刻派出去跑,直到撞到信號量耗盡的頭。也就是 work 入隊太快,wait 已把可用數扣光,而先前的 work 還沒跑完、signal 還無法補回數量。
若你有一堆 block 要跑,並希望在全部完成時收到通知,可以用 group。dispatch_group_async 讓你把任務加進隊列,並自動追蹤數量。同一個 dispatch group 可以放進來自不同隊列的任務,並統一追蹤;當所有被追蹤的任務都完成,傳給 dispatch_group_notify 的 block 就會被觸發,有點像 completion block。
dispatch_group_t group = dispatch_group_create() for item in someArray { dispatch_group_async(group, backgroundQueue, { performExpensiveWork(item: item) }) } dispatch_group_notify(group, dispatch_get_main_queue(), { // all the work is complete }想攤平一個帶 completion block 的函數,這是很好的範式:dispatch group 認為整個 block 在返回時才算完成,所以 block 會一直等到任務真正結束。
還有一種更手動的寫法,特別適合大量高開銷的異步任務:
// must be on a background thread dispatch_group_t group = dispatch_group_create() for item in someArray { dispatch_group_enter(group) performExpensiveAsyncWork(item: item, completionBlock: { dispatch_group_leave(group) }) } dispatch_group_wait(group, DISPATCH_TIME_FOREVER) // all the work is complete這段看起來複雜些,逐行讀還是可以理解。和信號量一樣,group 內部也維護著一個執行緒安全的計數器,用來確保多個重活都跑完之後才執行 completion block:enter 加一,leave 減一。dispatch_group_async 已經幫你把這些細節處理好了。
最後一行是 wait,它會阻斷當前執行緒,等計數器歸零才繼續。即使你用了 enter/leave,仍然可以用 dispatch_group_notify 把 block 提交到隊列;反過來,用了 dispatch_group_async 也能搭配 dispatch_group_wait。
dispatch_group_wait 和 dispatch_semaphore_wait 一樣接受超時參數,我一樣偏好 DISPATCH_TIME_FOREVER,也一樣不建議在主線程呼叫。
兩段程式碼最大的差別是:notify 可以完全從主線程呼叫,而 wait 只能用在後台執行緒(至少 wait 那部分如此,因為它會把當前執行緒完全卡住)。
Swift 的字典與陣列都是值型別,被修改時引用會換成新副本。但更新 Swift 物件的實例變數並非原子操作,因此也不是執行緒安全的。若兩個執行緒同時更新同一個字典(例如都新增一筆),而兩者又試圖寫入同一塊記憶體,就會造成記憶體毀損。隔離隊列正是用來解決這件事。
先建一個標識映射(Identity Map)——一個從 ID 對應到 model 物件的字典。
Identity Map 模式的思路是:把所有已載入的物件放進同一個映射,確保同一個物件只被載入一次,之後一律透過映射查找。在處理並發存取時,讓多個使用者共同作用於同一個業務實體的策略固然重要;同樣重要的是,單一使用者在長事務或複雜事務中,必須始終看到同一份一致版本。Identity Map 提供的正是這種能力:事務中用到的所有業務物件都保存同一個版本,同一個實體被請求兩次時回傳同一個物件。
class IdentityMap { var dictionary = Dictionary() func object(forID ID: String) -> T? { return dictionary[ID] as T? } func addObject(object: T) { dictionary[object.ID] = object } }基本上就是字典的包裝。若多個執行緒同時呼叫 addObject,記憶體就會毀損,因為它們操作的是同一個引用。這是作業系統裡典型的讀者—寫者問題:同一時刻可以有多個讀者,但只能有一個寫入者。
幸好 GCD 在這個場景也有強力工具,共四個 API 可選:
dispatch_sync
dispatch_async
dispatch_barrier_sync
dispatch_barrier_async
我們的目標是:讀操作可同步也可異步,寫操作走異步,但必須保證同一時刻只有一個寫入、且寫入時不能有人在讀。barrier 系列 API 正好合用——它會等隊列中先前的任務全部清空,才執行自己的 block。用 barrier 就能把寫入串行化,同時避免讀寫交錯。
class IdentityMap { var dictionary = Dictionary() let accessQueue = dispatch_queue_create("com.khanlou.isolation.queue", DISPATCH_QUEUE_CONCURRENT) func object(withID ID: String) -> T? { var result: T? = nil dispatch_sync(accessQueue, { result = dictionary[ID] as T? }) return result } func addObject(object: T) { dispatch_barrier_async(accessQueue, { dictionary[object.ID] = object }) } }dispatch_sync 把 block 派到隔離隊列並等待其完成,這樣就得到了同步讀取(若改成異步,getter 就得帶 completion block)。因為 accessQueue 是並發隊列,這些同步讀取可以同時進行,也就是允許並發讀。
dispatch_barrier_async 把 block 派到隔離隊列,async 意味著立即返回、不等 block 跑完,對效能有利;但副作用是緊接著的讀取可能讀到寫到一半的資料。
而 barrier 的意義在於:這個 block 進隊列後不會立刻執行,而是要等該隊列先前所有 block 都跑完;在它之後提交的 block 也得等它執行完。如此一來就保證了同一時刻只有寫入在進行,也保證寫入期間沒有讀取插入。
傳給 dispatch_barrier_async 的隊列,必須是用 dispatch_queue_create 建立的並發隊列。若傳入串行隊列或全域並發隊列,這個函數就退化成 dispatch_async 了。
GCD 是一套底層框架,我們可以在它之上搭建高階抽象。如果還有其他能用 GCD 打造的高階行為,歡迎一起交流。