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

iOS GCD 多執行緒完全指南:從 Dispatch Queue 到 Semaphore

編輯:iOS 開發綜合

Grand Central Dispatch(GCD)是負責異步執行任務的技術之一。它將原本需要開發者自行撰寫的執行緒管理程式碼下沉到系統層級實作:開發者只需定義想執行的任務,並將其追加到適當的 Dispatch Queue,GCD 便會自動建立必要的執行緒並排程執行。由於執行緒管理是系統的一部分,得以統一調度,因此比起以往的手動方式更有效率。

Dispatch Queue

Dispatch Queue 是執行任務的隊列,也是 GCD 最基本的元素之一。它分為兩種:

  • Serial Dispatch Queue(序列隊列):依加入隊列的順序(先進先出)一個接一個地執行。
  • Concurrent Dispatch Queue(並發隊列):並發執行隊列中的任務。

簡單來說,序列隊列只使用一個執行緒,而並發隊列會使用多個執行緒(具體數量由系統決定)。取得 Dispatch Queue 有兩種方式,第一種是自己建立:

let myQueue: dispatch_queue_t = dispatch_queue_create("com.xxx", nil)

第一個參數是隊列名稱,建議使用反是的完整網域名稱。雖然可以為隊列指定名稱並非強制,但有名稱的隊列在除錯時更為友善;當第二個參數為 nil 時,回傳的是 Serial Dispatch Queue;若指定為 DISPATCH_QUEUE_CONCURRENT,則回傳 Concurrent Dispatch Queue。

需要留意的是,若在 OS X 10.8 或 iOS 6 之後的版本使用,Dispatch Queue 會由 ARC 自動管理;若早於這些版本,則需手動釋放:

let myQueue: dispatch_queue_t = dispatch_queue_create("com.xxx", nil)

dispatch_async(myQueue, { () -> Void in

println("in Block")

})

dispatch_release(myQueue)

除了自行建立,第二種方式是直接取得系統提供的 Dispatch Queue。系統提供的隊列不外乎兩種:

  • Main Dispatch Queue
  • Global Dispatch Queue(Concurrent Dispatch Queue)

一般只有在更新 UI 時才需要取得 Main Dispatch Queue,其他情況用 Global Dispatch Queue 就能滿足需求:

// 取得 Main Dispatch Queue

let mainQueue = dispatch_get_main_queue()

// 取得 Global Dispatch Queue

let globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)

取得的 Global Dispatch Queue 實際上是一個 Concurrent Dispatch Queue,而 Main Dispatch Queue 則是 Serial Dispatch Queue(且僅有一個)。取得 Global Dispatch Queue 時可指定優先級,你能依實際情況決定使用哪一種。一般來說,透過第二種方式取得隊列即可。

dispatch_after

dispatch_after 能讓加入隊列的任務延遲執行。例如想讓某個 Block 在 10 秒後執行:

var time = dispatch_time(DISPATCH_TIME_NOW, (Int64)(10 * NSEC_PER_SEC))

dispatch_after(time, globalQueue) { () -> Void in

println("在 10 秒後執行")

}

NSEC_PER_SEC 代表秒數,此外還有 NSEC_PER_MSEC 代表毫秒。上面這句 dispatch_after 的真正含義是「在 10 秒後把任務加入隊列」,而非嚴格保證在 10 秒後執行;在大多數情況下它能達到預期,只有在對時間要求極為精準時才可能出問題。

取得 dispatch_time_t 型別的值有兩種方式:上面用的是 dispatch_time 函式(計算相對時間);另一種是 dispatch_walltime 函式(計算絕對時間),它需要使用 timespec 結構體。以下是一個把 NSDate 轉成 dispatch_time_t 的 Swift 方法:

func getDispatchTimeByDate(date: NSDate) -> dispatch_time_t {

let interval = date.timeIntervalSince1970

var second = 0.0

let subsecond = modf(interval, &second)

var time = timespec(tv_sec: __darwin_time_t(second), tv_nsec: (Int)(subsecond * (Double)(NSEC_PER_SEC)))

return dispatch_walltime(&time, 0)

}

這個方法接收一個 NSDate 物件,將其轉成 dispatch_walltime 所需的 timespec 結構,最後回傳 dispatch_time_t。同樣是 10 秒後執行,呼叫處改寫為:

var time = getDispatchTimeByDate(NSDate(timeIntervalSinceNow: 10))

dispatch_after(time, globalQueue) { () -> Void in

println("在 10 秒後執行")

}

這就是透過絕對時間使用 dispatch_after 的範例。

dispatch_group

我們常遇到這樣的情況:手上有 3 個 Block 要執行,我們不在乎它們的執行順序,只希望在這 3 個 Block 全部完成後,再執行某個操作。這時就需要 dispatch_group:

let globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)

let group = dispatch_group_create()

 dispatch_group_async(group, globalQueue) { () -> Void in println("1") } dispatch_group_async(group, globalQueue) { () -> Void in println("2") } dispatch_group_async(group, globalQueue) { () -> Void in println("3") } dispatch_group_notify(group, globalQueue) { () -> Void in println("completed") }

輸出的順序與加入隊列的順序無關(因為是並發隊列),但「completed」一定在最後輸出:

1
3
2
completed

除了用 dispatch_group_notify 取得「全部完成」的通知外,也可以使用 dispatch_group_wait:

 let globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0) let group = dispatch_group_create() dispatch_group_async(group, globalQueue) { () -> Void in println("1") } dispatch_group_async(group, globalQueue) { () -> Void in println("2") } dispatch_group_async(group, globalQueue) { () -> Void in println("3") } // 使用 dispatch_group_wait dispatch_group_wait(group, DISPATCH_TIME_FOREVER) println("completed")

需要注意的是,dispatch_group_wait 會使「當前執行緒」進入等待狀態。也就是說,若你在主執行緒呼叫它,在上述 Block 執行完之前,主執行緒會陷入卡死。它的第二個參數用來指定超時時間:若設為 DISPATCH_TIME_FOREVER 則會永久等待,直到所有 Block 執行完畢;也可指定具體的等待時間,並透過回傳值判斷是任務完成還是等待超時。

最後,與建立 dispatch_queue 一樣,若在 OS X 10.8 或 iOS 6 之後的版本使用,Dispatch Group 會由 ARC 自動管理;早於這些版本則需自行釋放。

dispatch_barrier_async

dispatch_barrier_async 顧名思義,是在隊列任務中插入一道「柵欄」。在柵欄之前已開始執行的 Block 會繼續執行;當 dispatch_barrier_async 準備執行時,其他 Block 會進入等待狀態,直到柵欄任務執行完畢,其後的 Block 才會繼續。以下用一個讀檔、寫檔的例子說明:

 func writeFile() { NSUserDefaults.standardUserDefaults().setInteger(7, forKey: "Integer_Key") } func readFile() { print(NSUserDefaults.standardUserDefaults().integerForKey("Integer_Key")) }

寫入只是往 NSUserDefaults 存入數字 7,讀取則是把這個數字印出來。要避免寫入時剛好有執行緒在讀取,就能使用 dispatch_barrier_async:

 NSUserDefaults.standardUserDefaults().setInteger(9, forKey: "Integer_Key") let globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0) dispatch_async(globalQueue) { self.readFile() } dispatch_async(globalQueue) { self.readFile() } dispatch_async(globalQueue) { self.readFile() } dispatch_async(globalQueue) { self.readFile() } dispatch_barrier_async(globalQueue) { self.writeFile() ; self.readFile() } dispatch_async(globalQueue) { self.readFile() } dispatch_async(globalQueue) { self.readFile() } dispatch_async(globalQueue) { self.readFile() }

我們先把 9 初始化到 NSUserDefaults 的 Integer_Key 中,再於中間執行 dispatch_barrier_async。由於這是並發隊列,同時能開幾條執行緒由系統決定:若加入柵欄時其他 Block(包含上面 4 個)還沒開始執行,則會先執行柵欄內的任務,其餘 Block 全部等待;若加入柵欄時已有 Block 在執行,則柵欄會等這些 Block 完成後再執行。

dispatch_apply

dispatch_apply 會將指定的 Block 執行指定的次數。當你想對某個陣列的所有元素執行相同操作時,它非常實用。用法很簡單:指定執行次數與 Dispatch Queue,Block 回呼中會帶有一個索引,就能依此判斷當前處理的是哪個元素:

 let globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0) dispatch_apply(10, globalQueue) { (index) -> Void in print(index) } print("completed")

由於是並發隊列,無法保證哪個索引先執行,但「completed」一定在最後印出——因為 dispatch_apply 是同步的,執行期間會使執行緒在此等待。因此,我們通常應該在一個異步執行緒中使用它:

 let globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0) dispatch_async(globalQueue, { () -> Void in dispatch_apply(10, globalQueue) { (index) -> Void in print(index) } print("completed") }) print("在 dispatch_apply 之前")

dispatch_suspend / dispatch_resume

某些情況下,我們可能想讓 Dispatch Queue 暫時停下,之後再恢復處理,這時就能使用 dispatch_suspend 與 dispatch_resume:

// 暫停

dispatch_suspend(globalQueue)

// 恢復

dispatch_resume(globalQueue)

暫停時,若已有 Block 正在執行,則不受影響;dispatch_suspend 只會影響尚未開始執行的 Block。

Dispatch Semaphore

信號量(Semaphore)在多執行緒開發中被廣泛使用。當一個執行緒進入一段關鍵程式碼之前,必須先取得信號量;關鍵程式碼完成後,則必須釋放信號量。其他想進入該區段的執行緒,都必須等待前一個執行緒釋放信號量。

其做法是:當信號計數大於 0 時,每個進入的執行緒使計數減 1,直到變為 0;變為 0 後其他執行緒便無法進入,只能等待;完成任務的執行緒釋放信號,使計數加 1,如此循環。下面的例子用了 10 條執行緒,但同時只有一條能執行,其餘皆在等待:

 let globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0) let semaphore = dispatch_semaphore_create(1) for i in 0...9 { dispatch_async(globalQueue, { () -> Void in dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER) let time = dispatch_time(DISPATCH_TIME_NOW, (Int64)(2 * NSEC_PER_SEC)) dispatch_after(time, globalQueue) { () -> Void in print("2 秒後執行") dispatch_semaphore_signal(semaphore) } }) }

取得信號量的執行緒在 2 秒後釋放,相當於每 2 秒執行一次。由此可見,在 GCD 中:用 dispatch_semaphore_create 初始化信號量並指定初始值;用 dispatch_semaphore_wait 分配信號量並使計數減 1,為 0 時進入等待;用 dispatch_semaphore_signal 釋放信號量並使計數加 1。

此外,dispatch_semaphore_wait 同樣支援超時,只要為第二個參數指定超時時間即可,並可透過回傳值判斷結果,用法類似 dispatch_group_wait。這個函式也需注意:若在 OS X 10.8 或 iOS 6 之後的版本使用,Dispatch Semaphore 會由 ARC 自動管理;早於這些版本則需自行釋放。

dispatch_once

dispatch_once 常用於單例模式,它能保證某段程式碼在整個程式運行期間只執行一次。以下示範如何在 Swift 中用 dispatch_once 建立單例類別:

 class SingletonObject { class var sharedInstance: SingletonObject { struct Static { static var onceToken: dispatch_once_t = 0 static var instance: SingletonObject? = nil } dispatch_once(&Static.onceToken) { Static.instance = SingletonObject() } return Static.instance! } }
  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved