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

GCD 實戰手冊:從後台隊列到信號量的最佳實踐

編輯:iOS 開發基礎

英文原文: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;   }

攤平 completion block

從這裡開始變得有趣。我們可以用信號量把一條執行緒阻塞任意長的時間,直到另一條執行緒發出信號。信號量與 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 done

dispatch_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 打造的高階行為,歡迎一起交流。

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