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

iOS GCD 基本用法:佇列、群組、柵欄與信號量一次搞懂

編輯: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 時回傳序列佇列(如上面的例子);若指定為 DISPATCH_QUEUE_CONCURRENT,則回傳並行佇列。

需要注意的是,在 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)

第二種方式是直接取得系統提供的佇列,共有兩種類型:

  • 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 實際上就是一個並行佇列,而 Main Dispatch Queue 則是序列佇列(而且只有一個)。取得 Global Dispatch Queue 時可以指定優先級,依實際情況挑選即可。多數情況下,用第二種方式取得佇列就能滿足需求。

dispatch_after:延遲執行

dispatch_after 能把加入佇列的任務延後執行。例如要讓一個區塊在 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_group:等待一組任務完成

有時候你會遇到這樣的需求:手上有 3 個區塊要跑,不在乎它們的執行順序,但希望三個都跑完之後再做某件事。這時就該用 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" 一定會出現在最後:

3
1
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 會讓目前的執行緒進入等待狀態。也就是說,如果你在主執行緒呼叫它,在上面的區塊全部跑完之前,主執行緒(連帶著 UI)就會卡住。

它的第二個參數用來指定逾時時間:寫成 DISPATCH_TIME_FOREVER(如本例)代表永久等待,直到所有區塊結束;也可以指定具體的等待時間,再依回傳值判斷是「區塊都跑完了」還是「等待逾時」。

最後,和建立佇列時一樣,若在 OS X 10.8 或 iOS 6 之後的版本使用,Dispatch Group 會由 ARC 自動管理;更早的版本則需手動釋放。

dispatch_barrier_async:在佇列中插入柵欄

顧名思義,dispatch_barrier_async 會在佇列的任務序列中插入一道「柵欄」。在它之前已經開始執行的區塊會繼續跑到底;而當它開始執行時,其他區塊都會被擋住進入等待;直到它執行完畢,後續的區塊才會繼續。這正是處理「讀寫衝突」的經典手法。

先準備讀檔與寫檔兩個方法:

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 寫進 Integer_Key,接著在中段插入柵欄任務。由於這是一個並行佇列,實際能同時跑幾條執行緒由系統決定:

  • 若加入 dispatch_barrier_async 時,其他區塊(包含前面那 4 個)還沒開始執行,那就會先執行柵欄裡的任務,其餘區塊全部進入等待。
  • 若加入時已經有區塊在跑,柵欄會等這些區塊跑完後才執行。

不論哪種情況,結果都一致:寫入不會被讀取插入到中間,資料一致性因此得到保障。

dispatch_apply:重複執行同一段任務

dispatch_apply 會把指定的區塊執行指定的次數。當你需要對陣列中所有元素套用同一份處理邏輯時,它特別好用——只要給定執行次數與佇列,回呼區塊會帶入一個索引,你就能依索引判斷目前處理的是哪個元素:

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_suspend(globalQueue)

// 恢復
dispatch_resume(globalQueue)

暫停時,若已經有區塊正在執行,該區塊不會受到影響。dispatch_suspend 只會攔住尚未開始執行的區塊。這個行為和記憶體管理中的 retain/release 有點像——暫停計數遞增、恢復計數遞減,只有計數歸零時佇列才會真正恢復運行,因此暫停幾次就要恢復幾次,別忘了配對。

Dispatch Semaphore:信號量

信號量在多執行緒開發中被廣泛使用。當一個執行緒要進入一段關鍵程式碼之前,必須先取得信號量;關鍵程式碼執行完畢後,再釋放信號量。其他想進入同一段程式碼的執行緒,就必須等前一個執行緒釋放。

具體機制是這樣的:信號計數大於 0 時,每個進來的執行緒讓計數減 1,直到變為 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 秒放行一個任務。

整理一下三個核心函式:

  • 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 中可以這樣寫:

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!
    }
}

如此一來,就由 GCD 的執行期機制保證初始化程式碼只會跑一次,不必再自己加上鎖與判斷,也不必擔心多執行緒同時建立出多個實例。

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