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

Grand Central Dispatch 深入教學(下):派發組、dispatch_apply、可取消的 Block 與 Dispatch Source

編輯:iOS 開發基礎

原文:Grand Central Dispatch Tutorial for Swift: Part 2/2

原文作者:Bjrn Olav Ruud 譯者:Ethan Joe

歡迎來到 Grand Central Dispatch 系列教學的第二部分!

在第一部分中,你學到了關於並發、執行緒與 GCD 運作原理的基礎知識,並用 dispatch_barrier_async 搭配 dispatch_sync 保證了 PhotoManager 單例在讀寫照片過程中的執行緒安全。你還用 dispatch_after 即時提醒使用者以優化 UX,並透過 dispatch_async 把部分工作從 View Controller 的實例化流程中切到另一執行緒,以處理 CPU 密集運算。

如果你一路從第一部分學到現在,可以直接沿用舊的專案檔繼續寫。若你沒有完成第一部分,或不想用自己的專案檔,可以從這裡下載第一部分完成後的完整專案。

好,是時候探索更多 GCD 知識了。

修掉提早出現的彈出提示

你應該已經注意到:當你透過 Le Internet 的方式新增照片時,在所有照片下載完成前,AlertView 就跳出來告訴你「Download Complete」了。

問題出在 PhotoManager 的 downloadPhotosWithCompletion 函數:

func downloadPhotosWithCompletion(completion: BatchPhotoDownloadingCompletionClosure?) {
    var storedError: NSError!
    for address in [OverlyAttachedGirlfriendURLString,
                    SuccessKidURLString,
                    LotsOfFacesURLString] {
        let url = NSURL(string: address)
        let photo = DownloadPhoto(url: url!) {
            image, error in
            if error != nil {
                storedError = error
            }
        }
        PhotoManager.sharedManager.addPhoto(photo)
    }
    if let completion = completion {
        completion(error: storedError)
    }
}

在函數結尾呼叫 completion 閉包,等於宣告你認為所有照片都下載完成了。但不幸的是,此時你並無法保證這件事。

DownloadPhoto 的實例化方法會從一個 URL 開始下載,並在下載完成前就立即傳回。也就是說,downloadPhotosWithCompletion 在結尾呼叫自己的 completion,就好像它是個線性同步執行的方法體——每個方法做完自己的工作就呼叫完成回呼。但 DownloadPhoto(url:) 是非同步執行且立刻返回的,所以這個寫法行不通。

正確的做法是:downloadPhotosWithCompletion 應該在所有照片的下載任務都呼叫過 completion 之後,才呼叫自己的 completion。問題來了——你怎麼監管那些同時執行的非同步事件?你根本不會知道它們何時、以何種順序結束。

或許你可以宣告多個 Bool 值來追蹤每個任務的下載狀態。說實話,這樣寫有點土,程式碼也會很亂。

幸好,派發組(dispatch groups)正是為了解決「監管多個非同步 completion」而生的。

派發組 Dispatch Group

派發組會在整組任務都完成時通知你。這些任務既可以是非同步的也可以是同步的,甚至可以分散在不同佇列中被監管。當全組任務完成時,派發組可以用同步或非同步的方式通知你。

GCD 提供兩種通知方式。第一個是 dispatch_group_wait,它會在組內所有任務完成之前(或逾時之後)持續阻塞當前執行緒。針對「提示提早出現」這個問題,dispatch_group_wait 正是最佳解法。

打開 PhotoManager.swift,用下面的程式碼替換原本的 downloadPhotosWithCompletion:

func downloadPhotosWithCompletion(completion: BatchPhotoDownloadingCompletionClosure?) {
    dispatch_async(GlobalUserInitiatedQueue) {   // 1
        var storedError: NSError!
        var downloadGroup = dispatch_group_create()   // 2
        for address in [OverlyAttachedGirlfriendURLString,
                        SuccessKidURLString,
                        LotsOfFacesURLString] {
            let url = NSURL(string: address)
            dispatch_group_enter(downloadGroup)   // 3
            let photo = DownloadPhoto(url: url!) {
                image, error in
                if let error = error {
                    storedError = error
                }
                dispatch_group_leave(downloadGroup)   // 4
            }
            PhotoManager.sharedManager.addPhoto(photo)
        }
        dispatch_group_wait(downloadGroup, DISPATCH_TIME_FOREVER)   // 5
        dispatch_async(GlobalMainQueue) {   // 6
            if let completion = completion {   // 7
                completion(error: storedError)
            }
        }
    }
}

逐步解說:

  1. 一旦使用會阻塞當前執行緒的同步式 dispatch_group_wait,就必須用 dispatch_async 把整個方法調到背景佇列,以保證主執行緒的正常運作。
  2. 這裡宣告了一個新的派發組,你可以把它想成「未完成任務計數器」。
  3. dispatch_group_enter 用來通知派發組有新任務開始。呼叫 dispatch_group_enter 的次數必須與 dispatch_group_leave 相等,否則會導致 App 崩潰。
  4. 在這裡通知派發組任務結束。再強調一次:進出派發組的次數一定要相等。
  5. dispatch_group_wait 會等到所有任務結束或逾時才返回。若逾時發生在任務完成之前,函數會傳回非零結果,你可以把它放進一個特殊閉包中判斷。本範例使用 DISPATCH_TIME_FOREVER 讓它一直等,因為照片下載終究會完成。
  6. 到目前為止,你已保證下載任務要麼順利完成、要麼逾時。接著可以回到主佇列執行 completion 閉包,這會把任務排入主執行緒稍後執行。
  7. 條件允許時執行 completion 閉包。

編譯並執行,你會發現點擊下載照片後,completion 閉包會在正確的時機被觸發。

提醒:當你在實體裝置上執行時,如果網路太快讓你難以判斷 completion 的執行時機,可以到 App 設定中的 Developer 區段調整網路條件。打開 Network Link Conditioner 並選擇 Very Bad Network 是個好選擇。若在模擬器上執行,則可使用包含在 Hardware IO Tools for Xcode 中的 Network Link Conditioner 來調整網速——這是測試弱網環境下 App 行為的絕佳工具。

這個解法的好處不止於此,但整體而言它在大多數情況下避免了阻塞執行緒的可能。你接下來的任務,是寫一個以非同步方式發出「照片下載完成」通知的版本。

開始之前,先快速了解不同類型佇列下派發組的使用時機:

  • 自訂序列佇列:當需要在組內任務全部完成時發出通知,這是個不錯的選擇。
  • 主佇列(序列):當你以同步方式等待所有任務完成、又不想阻塞主佇列時,應該在主執行緒上謹慎使用它。但對於網路請求這類長時間任務,用非同步方式在主佇列上更新 UI 才是絕佳做法。
  • 並發佇列:對派發組與完成通知來說也是不錯的選擇。

派發組,再來一次

出於精益求精:把下載任務非同步派發到另一個佇列、再用 dispatch_group_wait 阻塞它的做法,是不是有點笨?試試另一條路。

用下面的實作替換 PhotoManager.swift 中的 downloadPhotosWithCompletion:

func downloadPhotosWithCompletion(completion: BatchPhotoDownloadingCompletionClosure?) {
    // 1
    var storedError: NSError!
    var downloadGroup = dispatch_group_create()

    for address in [OverlyAttachedGirlfriendURLString,
                    SuccessKidURLString,
                    LotsOfFacesURLString] {
        let url = NSURL(string: address)
        dispatch_group_enter(downloadGroup)
        let photo = DownloadPhoto(url: url!) {
            image, error in
            if let error = error {
                storedError = error
            }
            dispatch_group_leave(downloadGroup)
        }
        PhotoManager.sharedManager.addPhoto(photo)
    }

    dispatch_group_notify(downloadGroup, GlobalMainQueue) {   // 2
        if let completion = completion {
            completion(error: storedError)
        }
    }
}

新的非同步版本運作方式:

  1. 在新的實作中,由於不再阻塞主執行緒,就沒有必要把整段包進 dispatch_async。
  2. dispatch_group_notify 相當於一個非同步的 completion 閉包。當派發組中不再剩餘任何任務、輪到 completion 執行時,這段程式碼就會被呼叫。你也可以指定 completion 在哪個佇列上執行——這裡我們選主佇列。

對於「不阻塞任何執行緒」這種需求,這是相當簡潔的寫法。

過度使用並發機制的風險

學了這麼多新東西,是不是該把你的程式碼全部執行緒化?

看看 PhotoManager 中的 downloadPhotosWithCompletion,你應該注意到那個在三個參數之間迴圈、下載三張不同照片的 for 迴圈。接下來的挑戰是:用並發機制加快這個迴圈。該 dispatch_apply 上場了。

dispatch_apply 就像一個以並發形式執行各次迭代的 for 迴圈。與普通 for 迴圈一樣,它是同步執行、所有工作完成後才返回的函數。

設定迭代次數時務必小心:當存在多次迭代而每次迭代只包含少量工作時,資源的消耗會抵銷並發帶來的收益。這種情況可以用 striding 技術來改善——把多個任務合併到較少的迭代中處理。

什麼時候適合用 dispatch_apply?

  • 自訂序列佇列:對序列佇列來說 dispatch_apply 沒什麼用處,老實用普通 for 迴圈吧。
  • 主佇列(序列):同上,用普通 for 迴圈。
  • 並發佇列:當你需要掌握任務處理進度時,並發迴圈是個好主意。

回到 downloadPhotosWithCompletion,替換成下面的程式碼:

func downloadPhotosWithCompletion(completion: BatchPhotoDownloadingCompletionClosure?) {
    var storedError: NSError!
    var downloadGroup = dispatch_group_create()
    let addresses = [OverlyAttachedGirlfriendURLString,
                     SuccessKidURLString,
                     LotsOfFacesURLString]

    dispatch_apply(addresses.count, GlobalUserInitiatedQueue) {
        i in
        let index = Int(i)
        let address = addresses[index]
        let url = NSURL(string: address)
        dispatch_group_enter(downloadGroup)
        let photo = DownloadPhoto(url: url!) {
            image, error in
            if let error = error {
                storedError = error
            }
            dispatch_group_leave(downloadGroup)
        }
        PhotoManager.sharedManager.addPhoto(photo)
    }

    dispatch_group_notify(downloadGroup, GlobalMainQueue) {
        if let completion = completion {
            completion(error: storedError)
        }
    }
}

現在你的迴圈以並發方式執行。呼叫 dispatch_apply 時提供了三個參數:第一個宣告迭代次數,第二個宣告執行任務的佇列,第三個是閉包。

要留意的是:即使你已有執行緒安全的加照片程式碼,照片的順序仍會依最先完成的那個執行緒排列。

編譯執行,用 Le Internet 的方式新增一些照片,注意到差別了嗎?在實體裝置上跑修改後的程式碼偶爾會快一些。那麼,這個改動值得嗎?

其實在這種情況下並不值得,原因如下:

  • 你已經產生了比 for 迴圈更多的執行緒,dispatch_apply 在這裡有小題大作之嫌。
  • 寫 App 的時間有限——別為那些「抓雞不成蝕把米」的優化浪費時間,把精力放在能帶來明顯效益的地方。你可以用 Xcode 的 Instruments 找出 App 中執行時間最長的方法。
  • 某些情況下,優化後的程式碼反而增加了理解其邏輯結構的難度,所以優化一定要物有所值。

記住:不要癡迷於優化,不然就是跟自己過不去。

取消派發塊(dispatch block)的執行

iOS 8 與 OS X Yosemite 加入了名為 dispatch block objects 的新功能。它能做不少事,例如為每個物件設定 QoS 等級來決定其在佇列中的優先級,但它最特別的能力是「取消 block 的執行」。要記住:一個 block 只有在抵達佇列頂端、開始執行之前,才能被取消。

我們用「透過 Le Internet 開始並取消照片下載」來說明這個機制。用下面的程式碼替換 PhotoManager.swift 中的 downloadPhotosWithCompletion:

func downloadPhotosWithCompletion(completion: BatchPhotoDownloadingCompletionClosure?) {
    var storedError: NSError!
    let downloadGroup = dispatch_group_create()
    var addresses = [OverlyAttachedGirlfriendURLString,
                     SuccessKidURLString,
                     LotsOfFacesURLString]
    addresses += addresses + addresses   // 1

    var blocks: [dispatch_block_t] = []   // 2

    for i in 0 ..< addresses.count {
        dispatch_group_enter(downloadGroup)
        let block = dispatch_block_create(DISPATCH_BLOCK_INHERIT_QOS_CLASS) {   // 3
            let index = Int(i)
            let address = addresses[index]
            let url = NSURL(string: address)
            let photo = DownloadPhoto(url: url!) {
                image, error in
                if let error = error {
                    storedError = error
                }
                dispatch_group_leave(downloadGroup)
            }
            PhotoManager.sharedManager.addPhoto(photo)
        }
        blocks.append(block)
        dispatch_async(GlobalMainQueue, block)   // 4
    }

    for block in blocks[3 ..< blocks.count] {   // 5
        let cancel = arc4random_uniform(2)   // 6
        if cancel == 1 {
            dispatch_block_cancel(block)   // 7
            dispatch_group_leave(downloadGroup)   // 8
        }
    }

    dispatch_group_notify(downloadGroup, GlobalMainQueue) {
        if let completion = completion {
            completion(error: storedError)
        }
    }
}
  1. addresses 陣列中的每個元素都被複製了三份。
  2. 這個陣列用來保存稍後要使用的 block objects。
  3. dispatch_block_create 宣告一個新的 block 物件。第一個參數是定義 block 特性的旗標,這裡讓 block 繼承被派發到佇列時的 QoS 等級;第二個參數是以閉包形式定義的 block。
  4. 以非同步形式把 block 派發到主佇列。這裡使用的主佇列是一個序列佇列,因此更容易取消所選的 blocks。由於派發 blocks 的程式碼本身在主佇列上執行,就保證了下載 blocks 會稍後才被執行。
  5. 跳過前三次下載,對剩餘的陣列元素執行迴圈。
  6. arc4random_uniform 會傳回 0 到上限之間(不含上限)的整數。就像擲硬幣一樣,把上限設為 2 就會得到 0 或 1。
  7. 若隨機數為 1,且 block 還在佇列中尚未執行,則取消它。執行中的 block 無法被取消。
  8. 當所有 blocks 都被加入佇列後,別忘了把被取消的那些從派發組中扣除。

編譯執行 App,透過 Le Internet 新增照片。你會發現 App 在下載原來的三張照片後,還會再下載隨機數量的照片,其餘的 blocks 在派發到佇列後被取消。這例子有點牽強,但很好地說明了 dispatch block objects 的使用與取消方式。它能做的還很多,使用前別忘了翻翻官方文件。

GCD 帶來的更多樂趣

且慢!再容我補充一些不常用但很實用的函數。

測試非同步程式碼

這聽起來有點不靠譜,但 Xcode 的確支援這類測試。在某些情況下我會假裝不知道有這功能,但在處理關係複雜的程式碼時,編寫與執行測試非常重要。

Xcode 的測試以 XCTestCase 的子類形式出現,其中任何以 test 開頭的方法都會被執行。測試在主執行緒上運行,所以你可以假設每個測試都是序列執行的。

一旦某個測試方法執行完畢,XCTest 就認定該測試結束並開始下一個——這意味著上一個測試中的非同步程式碼可能還在背景繼續跑。當你執行網路請求又不想阻塞主執行緒時,這類任務通常是非同步的,於是「測試方法結束即代表測試結束」的機制就讓網路程式碼的測試變得棘手。

別緊張,接著看兩種專門測試非同步程式碼的常用技術:一種用信號量(semaphores),另一種用期望(expectations)。

信號量 Semaphores

在許多學校的作業系統課程中,一講到 Edsger W. Dijkstra 就一定會提到信號量這個與執行緒相關的概念。信號量的難處在於它建立在複雜的作業系統函數之上。

如果你想深入了解信號量理論,可以查到更多細節;若你是偏學術派,從軟體開發角度看,信號量的經典例子大概就是「哲學家就餐問題」了。

信號量適用於在資源有限的情況下控制多個單位的資源消耗。舉例來說,若你宣告了一個包含兩個資源的信號量,同一時間最多只能有兩個執行緒進入臨界區;其他想用資源的執行緒必須以 FIFO 順序在佇列中等待。

打開 GooglyPuffTests.swift,用下面的程式碼替換 downloadImageURLWithString 函數:

func downloadImageURLWithString(urlString: String) {
    let url = NSURL(string: urlString)
    let semaphore = dispatch_semaphore_create(0)   // 1
    let photo = DownloadPhoto(url: url!) {
        image, error in
        if let error = error {
            XCTFail("\(urlString) failed. \(error.localizedDescription)")
        }
        dispatch_semaphore_signal(semaphore)   // 2
    }
    let timeout = dispatch_time(DISPATCH_TIME_NOW, DefaultTimeoutLengthInNanoSeconds)
    if dispatch_semaphore_wait(semaphore, timeout) != 0 {   // 3
        XCTFail("\(urlString) timed out")
    }
}

信號量在此的運作方式:

  1. 建立信號量。參數代表初始值,也就是同時能存取信號量的執行緒數量;我們通常以發送信號的方式來增加這個值。
  2. 在 completion 閉包中宣告你不再需要資源,信號量的值隨之增加,並向其他等待者宣告資源可用。
  3. 設定信號量請求的逾時時間。在信號量宣告可用之前,當前執行緒會被阻塞;若逾時,函數會傳回非零值,此時測試失敗——因為它認為網路請求不該超過十秒。

透過選單中的 Product/Test 執行測試,或使用 Cmd + U 快捷鍵。斷開網路連線後再次執行;若在實機上就跑飛行模式,模擬器則直接斷網。十秒後這次測試會以失敗告終。

如果你是伺服器團隊的一員,這些測試仍然很重要。

期望 Expectations

XCTest 框架提供了另一個測試非同步程式碼的方案:期望。它允許你在非同步任務開始前設定一個期望——某件你期待發生的事。在期望被標記為 fulfilled 之前,你可以讓測試執行器持續等待。

用下面的程式碼替換 GooglyPuffTests.swift 中的 downloadImageWithString 函數:

func downloadImageURLWithString(urlString: String) {
    let url = NSURL(string: urlString)
    let downloadExpectation = expectationWithDescription("Image downloaded from \(urlString)")   // 1
    let photo = DownloadPhoto(url: url!) {
        image, error in
        if let error = error {
            XCTFail("\(urlString) failed. \(error.localizedDescription)")
        }
        downloadExpectation.fulfill()   // 2
    }
    waitForExpectationsWithTimeout(10) {   // 3
        error in
        if let error = error {
            XCTFail(error.localizedDescription)
        }
    }
}

說明:

  1. 透過 expectationWithDescription 宣告一個期望。測試失敗時,測試執行器會在日誌中顯示這段描述字串,代表你期待發生的事。
  2. 在非同步閉包中呼叫 fulfill,把期望標記為已完成。
  3. 呼叫的執行緒透過 waitForExpectationsWithTimeout 等待期望被標記完成;若逾時,則視為錯誤。

編譯並執行測試。結果與信號量方案差異不大,但這種寫法讓 XCTest 框架更簡潔易讀。

使用派發源 Dispatch Sources

GCD 有個非常有趣的特性叫派發源,它包裝了大量低層級功能,能幫你監聽 Unix 信號、檔案描述符、Mach 連接埠、VFS Nodes 等事件並做出回應。這些主題超出本教程範圍,但我認為你應該動手做一個派發源物件。

很多初學者卡在「如何使用一個源」上,所以要先清楚 dispatch_source_create 的運作方式。函數宣告如下:

func dispatch_source_create(
    type: dispatch_source_type_t,
    handle: UInt,
    mask: UInt,
    queue: dispatch_queue_t!) -> dispatch_source_t!

第一個參數 type 決定了後續 handle 與 mask 參數的型別。你可以查官方文件了解每一種 dispatch_source_type_t 的用法。

這裡我們要監管 DISPATCH_SOURCE_TYPE_SIGNAL。如官方文件所述:派發源監管當前進程的信號,其 handle 是一個整數(int),mask 暫時用不到而設為 0。

這些 Unix 信號定義在 signal.h 標頭檔中,檔案頂端有大量 #define。在這堆信號中,我們要監管 SIGSTOP——當進程收到不可避免的暫停掛起指令時就會送出這個信號;用 LLDB 除錯器除錯時同樣會送出。

打開 PhotoCollectionViewController.swift,在 viewDidLoad 附近加入:

#if DEBUG
private var signalSource: dispatch_source_t!
private var signalOnceToken = dispatch_once_t()
#endif

override func viewDidLoad() {
    super.viewDidLoad()

    #if DEBUG   // 1
    dispatch_once(&signalOnceToken) {   // 2
        let queue = dispatch_get_main_queue()
        self.signalSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_SIGNAL,
                                                   UInt(SIGSTOP), 0, queue)   // 3
        if let source = self.signalSource {   // 4
            dispatch_source_set_event_handler(source) {   // 5
                NSLog("Hi, I am: \(self.description)")
            }
            dispatch_resume(source)   // 6
        }
    }
    #endif

    // The other stuff
}

逐步說明:

  1. 從安全角度考慮,最好只在 DEBUG 模式下編譯這段程式碼,以防他人間接看到。可透過 Project Settings → Build Settings → Swift Compiler – Custom Flags → Other Swift Flags → Debug,加入 -D DEBUG 來定義 DEBUG。
  2. 用 dispatch_once 對派發源做單次初始化。
  3. 這裡建立 signalSource 變數,表明只想做信號監管,並把 SIGSTOP 作為第二個參數。另外要注意:你使用主佇列來處理收到的事件——原因稍後就會明白。
  4. 若提供了錯誤的參數,派發源物件不會被成功建立。所以使用前一定要確認自己拿到的是可用的派發源物件。
  5. dispatch_source_set_event_handler 註冊一個在該信號送達時被呼叫的事件處理閉包。
  6. 預設情況下,所有派發源都以暫停狀態啟動。當你準備開始監管事件時,必須讓它重新開始運行。

編譯並執行 App;用除錯器暫停 App 執行,然後立刻恢復。檢查主控台,你會看到類似這樣的回饋:

2014-08-12 12:24:00.514 GooglyPuff[24985:5481978] Hi, I am:

某種程度上,你的 App 現在「知道」自己正在被除錯了。這不錯,但實際上能怎麼用?

重新恢復 App 執行時,你可以用它對某個物件做除錯並顯示相關數據;當某些不懷好意的人想用除錯器干擾 App 正常運作時,你也可以為 App 寫一個自訂的安全防護模組。

另一個有趣的想法是:透過這個機制實作一個除錯器物件堆疊追蹤器。

考慮這種情況:你意外停止了除錯器的執行,而除錯器很難停留在預期的堆疊框架上。但現在你可以隨時停止除錯器,並在任何地方執行程式碼。若你想在 App 的特定位置執行程式碼,這會非常有用。

在 viewDidLoad 事件處理閉包中的 NSLog 旁加上中斷點。在除錯器中暫停執行再恢復,App 會運行到中斷點所在處。現在你可以隨心所欲地存取 PhotoCollectionViewController 的實例了。

如果你不確定除錯器裡有哪些執行緒,可以去查一下。主執行緒永遠是第一個被 libdispatch 跟隨的執行緒,GCD 的協調器總是第二個,其他執行緒則視具體情況而定。

利用中斷點,你可以逐步更新 UI、測試類別的屬性,甚至在不重新執行 App 的情況下呼叫特定方法——很方便吧!

接下來往哪走?

你可以在這裡下載本教程的完整程式碼。

我不太愛囉嗦,但還是建議你去看看關於如何使用 Xcode Instruments 的教學。如果你打算優化 App,絕對會用到 Instruments——它在推斷效能瓶頸時非常有用:能比較不同程式碼區塊的相對執行時間,找出最耗時的那一段。

同時,你也值得看看 How to Use NSOperations and NSOperationQueue Tutorial in Swift。NSOperations 能提供更好的控制力,可以限制同時並發的任務數量,代價是犧牲一些執行速度、換來更物件導向的結構。

記住!在大多數情況下,除非有特別理由,一定要盡量使用高階 API。只有當你真心想學到或做到一些有趣的事情時,再去探索 Apple 的 Dark Arts 吧!

祝你好運!

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