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

Grand Central Dispatch 基礎教程:Part 1

編輯:iOS 開發基礎

原文 Grand Central Dispatch Tutorial for Swift: Part 1/2
原文作者:Bjørn Olav Ruud
譯者:Ethan Joe

Grand Central Dispatch(以下簡稱 GCD)推出已經有一段時間,但真正搞懂它運作原理的人並不多。這其實不難理解:並發本身就是個繁瑣的題目,而這套以 C 為基礎的 GCD API,放到 Swift 的世界裡看也確實不太親切。

接下來兩篇教程會把 GCD 的輸入與輸出講清楚。第一篇解釋 GCD 是什麼,並熟悉幾個基礎函數;第二篇則會談幾個更進階的用法。

Getting Started

GCD 是 libdispatch 的通稱,而 libdispatch 就是在 iOS 與 OS X 的多核設備上執行平行程式碼的官方函式庫。它常被歸納出兩個特點:

  • 把高成本的任務延後執行、調到背景去跑,藉此提升 App 的互動流暢度。

  • 提供比鎖與多執行緒更簡單的並發模型,避開一些由並發引起的 Bug。

要理解 GCD,得先搞清楚幾個和執行緒、並發相關的概念。這些術語之間有細微而模糊的差別,所以入門前先花點時間熟悉一下。

序列 vs 並發

這兩個詞用來描述被執行的任務彼此間的關係。序列執行代表同一時間只跑一個任務;並發執行則代表同一時間可能有複數任務在跑。

任務

在這篇教程裡,你可以把每個任務視為一個閉包。技術上也能用函式指標來使用 GCD,但多數情況那樣寫明顯更麻煩,閉包簡單得多。

不熟悉 Swift 的閉包?閉包就是可以儲存、可以傳遞的可呼叫程式碼塊,被呼叫時能像函式一樣帶參數並回傳值。

Swift 的閉包和 Objective-C 的 block 相當接近,兩者大致可以互換。唯一要注意的是:你不能用 Objective-C 的 block 去搭配具 Swift 專屬特性的閉包,比如帶 tuple 參數的那些。反方向則毫無障礙,所以不論何時你在文件中看到 Objective-C 的 block 寫法,都可以直接換成 Swift 閉包。

同步 vs 非同步

這兩個詞描述的是:當函式把控制權交還給呼叫者時,它交代的工作完成了多少。

同步函式只有在它交代的任務完成後才會回傳。

非同步函式則不會等任務做完,會立刻回傳。因此非同步函式不會把當前執行緒鎖住,讓它無法去處理佇列裡的下一位。

值得注意的是,當你看到某個函式「鎖住」(block)了當前 process,或稱它是鎖定函式(blocking function)時,不要跟 Objective-C 的 block 搞混。這裡的「鎖」形容的是它對自己那條執行緒的影響,跟 block 這種語法構造沒關係。另外也記得,GCD 文件中提到 Objective-C block 的地方,都能用 Swift 閉包取代。

臨界區

指一段不能同時在兩條執行緒上執行的程式碼。原因是這段程式碼負責管理某些共享資源(例如變數),一旦被並發存取就可能出問題。

資源競爭

指軟體系統的行為依賴於特定佇列,或依賴事件發生的時序,比如多個任務目前的執行順序。資源競爭產生的錯誤往往不會在除錯時立刻現形。

死鎖

兩個以上的 process 因為互相等待對方完成而全部停住的情況。舉例來說,process A 等 B 完成才繼續,而 B 又在等 A 完成,於是兩邊僵在那裡,這就是死鎖。

執行緒安全

具備執行緒安全的程式碼,可以在多執行緒或並發任務之間被安全呼叫而不出問題(例如資料被竄改、程式崩潰)。不具執行緒安全的程式碼,只有在單一環境下才能保證正常運作。舉個例子:let a = ["thread-safe"],這個唯讀陣列你可以在多條執行緒之間自由讀取而不出錯。相反地,var a = ["thread-unsafe"] 宣告的陣列是可變的,多執行緒同時動它就會產生難以預測的問題。所以可變變數與可變資料結構,最好不要同時在多條執行緒上使用。

上下文切換

指在一個 process 的多條不同執行緒之間切換時,對狀態所做的儲存與恢復。寫多工作 App 時相當常見,但通常會帶來額外的系統負擔。

並發 vs 平行

這兩個詞總是被一起提及,所以有點必要說清楚差別。

並發程式碼的各個獨立部分可以被「同時」執行——至於實際怎麼執行,由系統決定。多核設備用平行的方式在該時刻真正同時跑多條執行緒;單核設備則只能同時跑一條,靠上下文切換在執行緒間跳來跳去,達到類似平行的效果。下圖中,單核設備因為切換得夠快,形成了一種平行的假象。

並發 vs 平行

雖然你在 GCD 下寫的程式會用到多執行緒,但是否真的並發仍由 GCD 決定。平行包含並發,但並發不保證平行。

佇列

GCD 以佇列的方式分配待執行的任務。這些佇列管理你交給 GCD 的任務,並以 FIFO 順序處理:第一個進佇列的任務會被最先處理,第二個接著處理,依此類推。

序列佇列

序列佇列每次只執行一個任務,前一個任務跑完,下一個才開始。下圖中,你無從得知前一個任務結束到下一個任務開始之間隔了多久。

序列佇列

每個任務的執行時機由 GCD 決定;你唯一能確定的是,GCD 會在同一時間只跑一個任務,且順序就是入佇列的順序。

因為序列佇列不允許複數任務同時跑,同時進入臨界區的風險自然降低,這種機制在多任務的資源競爭中保護了臨界區。假如把任務分派到同一個序列佇列是存取臨界區的唯一途徑,那臨界區就是安全的。

並發佇列

並發佇列中的任務依然以 FIFO 順序開始執行……但你能確知的也就這樣了。任務可能以任何順序結束,你無法得知下一個任務何時開始,也不知道一段時間內究竟有幾個任務在跑,因為這一切都由 GCD 決定。

下圖是 GCD 控制下的四個並發任務:

並發佇列

可以注意到,任務 0 開始後過了一段時間任務 1 才啟動,但任務 1、2、3 隨後就一個接一個快速跑起來。另外,任務 3 雖然比任務 2 晚開始,卻更早結束。

任務何時開始完全由 GCD 決定。如果兩個任務的執行時間重疊,是否用不同處理器分開跑、還是靠上下文切換輪流跑,同樣由 GCD 判斷(前提是核心數夠且不忙)。

為了讓使用上更有彈性,GCD 提供了至少五種預先定義好的佇列來對應不同情境。

佇列種類

首先,系統提供了一個名為主佇列(main queue)的特殊序列佇列。和其他序列佇列一樣,它同一時間只跑一個任務;但不同的是,它保證所有任務都會在唯一被允許更新 UI 的那條執行緒上執行,它也是唯一可以對 UIView 送訊息或推送 Notification 的地方。

GCD 另外還提供了幾個並發佇列,每個都關聯著自己的 QoS(Quality of Service)類別。QoS 代表待處理任務的執行意圖,GCD 會依意圖決定最合適的優先權。

  • QOS_CLASS_USER_INTERACTIVE:代表為了良好使用者體驗而必須立刻執行的任務,常用於更新 UI 或處理低延遲需求的載入。App 運行期間,這個類別的工作量應該保持很小。

  • QOS_CLASS_USER_INITIATED:代表由 UI 觸發、可非同步執行的任務。適合用在用戶正在等待回饋,或需要維持互動連貫性的場合。

  • QOS_CLASS_UTILITY:代表長時間執行的任務,特別是那種需要顯示進度條給用戶看的。常用於運算、I/O、網路通訊、資料持續回饋等。這個類別以效率為設計重點。

  • QOS_CLASS_BACKGROUND:代表用戶不需要立即知情的任務,常用於預處理、維護,或那些對完成時間沒什麼要求的背景工作。

要知道 Apple 自家的 API 也在用這些全域佇列,所以你分派的任務不會是佇列裡唯一的一個。

最後,你也可以自己建立序列或並發佇列。算起來,你手上起碼有五個佇列可用:主佇列、四個全域佇列,再加上你自己的。

以上就是佇列的全體成員。GCD 的關鍵在於選對分派函式,把任務送到正確的佇列。理解這些最好的方式,就是動手做完下面的 Sample Project。

Sample Project

既然這篇教程的目標是學會用 GCD 在不同執行緒之間安全地呼叫程式碼,那接下來就把這個名為 GooglyPuff 的半成品補完。

GooglyPuff 是一款用 Core Image 臉部辨識 API 在照片人臉的雙眼位置貼上滑稽大眼睛的 App,而它目前的實作是執行緒不安全的。你可以從相簿選照片,也可以從預先設定好的網路位址下載。

GooglyPuff Swift Start 1

把專案下載到本機,用 Xcode 打開並編譯執行,它長這樣:

GooglyPuff

工程裡有四個類別檔案:

  • PhotoCollectionViewController:App 啟動後的第一個畫面,會顯示所有已選照片的縮圖。

  • PhotoDetailViewController:負責把滑稽眼睛加到照片上,並把處理完的照片顯示在 UIScrollView 中。

  • Photo:一個描述照片基本屬性的協議,包含 image(未處理照片)、thumbnail(裁切後縮圖)與 status(照片是否可用);實作該協議的兩個類別中,DownloadPhoto 從 NSURL 實例化照片,AssetPhoto 則從 ALAsset 實例化。

  • PhotoManager:管理所有 Photo 型別物件。

用 dispatch_async 處理背景任務

回到剛才執行的 App,從相簿加幾張照片,或從網路下載幾張。你會注意到,點擊 PhotoCollectionViewController 中的 UICollectionViewCell 後,畫面切到新的 PhotoDetailViewController 有明显停頓;在效能較差的設備上,處理一張大圖會產生相當明顯的延遲。

這種情況很容易讓 UIViewController 的 viewDidLoad 因為塞了太多工作而過載,結果就是 view controller 出現前先卡一長段。如果可能的話,我們最好把某些工作丟到背景去。

這聽起來該 dispatch_async 出場了。

打開 PhotoDetailViewController,把 viewDidLoad 換成下面的程式碼:

override func viewDidLoad() { super.viewDidLoad() assert(image != nil, "Image not set; required to use view  controller") photoImageView.image = image // Resize if neccessary to ensure it's not pixelated if image.size.height <= photoImageView.bounds.size.height & image.size.width <= photoImageView.bounds.size.width { photoImageView.contentMode = .Center } dispatch_async(dispatch_get_global_queue(Int(QOS_CLASS_USER_INITIATED.value), 0)) { // 1 let overlayImage = self.faceOverlayImageFromImage(self.image) dispatch_async(dispatch_get_main_queue()) { // 2 self.fadeInNewImage(overlayImage) // 3   }  } }

逐段說明:

  1. 你先把照片處理從主執行緒移到一個全域佇列。因為 dispatch_async 是非同步派發,閉包傳進去之後呼叫端會繼續往下跑,於是 viewDidLoad 能更早結束,整個載入過程更順;而臉部辨識 meanwhile 已經開始,一段時間後完成。

  2. 辨識結束、新照片生成之後,你想用它來更新 UIImageView,這時要把一個新的閉包派回主執行緒。記住——只有主執行緒才能存取 UIKit。

  3. 最後用帶滑稽眼睛的這張圖淡入更新 UI。

有沒有注意到你用了 Swift 的尾隨閉包語法?把閉包寫在呼叫括號外面,語法看起來更清爽。

編譯執行,選一張照片,你會發現 view controller 載入快多了,滑稽眼睛在短暫延遲後出現。現在的體驗比之前好很多;即使換成一張大到離譜的照片,App 也不會在切換 view controller 時卡住。

總結一下:dispatch_async 把任務以閉包形式塞進佇列後立刻回傳,任務在之後的某個時刻由 GCD 執行。當你想在不影響當前執行緒的前提下,把網路請求或高 CPU 消耗的工作移到背景,它就是正解。

接著是關於搭配 dispatch_async 時,不同佇列該怎麼選的簡明指南:

  • 自訂序列佇列:想把任務移到背景執行、同時隨時掌握它的狀態時,這是不錯的選擇。注意若你想從某個方法取得資料,得再寫一個閉包做回調,或考慮 dispatch_sync。

  • 主佇列(序列):並發佇列中的任務完成後要更新 UI 時的常見選擇,做法是閉包裡再包一層閉包。若你已經在主執行緒上又對主佇列呼叫 dispatch_async,那個新任務會在當前函式結束後才開始。

  • 並發佇列:要跑背景的非 UI 工作時的常見選擇。

為取得全域佇列加上簡潔變數

你可能也覺得 dispatch_get_global_queue 裡那個 QoS 參數寫起來很囉嗦——因為 qos_class_t 是個值型別為 UInt32 的結構體,最後還得轉成 Int。我們可以在 Utils.swift 的 URL 變數下面加幾個全域簡潔變數,讓取得全域佇列更省事。

var GlobalMainQueue: dispatch_queue_t { return dispatch_get_main_queue() } var GlobalUserInteractiveQueue: dispatch_queue_t { return dispatch_get_global_queue(Int(QOS_CLASS_USER_INTERACTIVE.value), 0) } var GlobalUserInitiatedQueue: dispatch_queue_t { return dispatch_get_global_queue(Int(QOS_CLASS_USER_INITIATED.value), 0) } var GlobalUtilityQueue: dispatch_queue_t { return dispatch_get_global_queue(Int(QOS_CLASS_UTILITY.value), 0) } var GlobalBackgroundQueue: dispatch_queue_t { return dispatch_get_global_queue(Int(QOS_CLASS_BACKGROUND.value), 0) }

回到 PhotoDetailViewController 的 viewDidLoad,用這些變數取代原本的呼叫:

dispatch_async(GlobalUserInitiatedQueue) {    let overlayImage = self.faceOverlayImageFromImage(self.image)    dispatch_async(GlobalMainQueue) {      self.fadeInNewImage(overlayImage)    }  }

可讀性好了不少,一眼就看得出用的是哪個佇列。

用 dispatch_after 做延遲

想一下你 App 的使用體驗:用戶第一次打開時,會不會因為不知道該幹嘛而一頭霧水?

如果 PhotoManager 裡一張照片都沒有,那就給用戶一個提示,這主意不錯。但你也得考慮用戶在主畫面上的注意力:提示出現得太快,用戶可能正在看別的地方就這樣錯過了。

首次使用時,讓提示延遲一秒出現,大概足以抓住目光。

在 PhotoCollectionViewController.swift 尾端的 showOrHideNavPrompt 函式裡加上:

func showOrHideNavPrompt() {    let delayInSeconds = 1.0    let popTime = dispatch_time(DISPATCH_TIME_NOW,                              Int64(delayInSeconds * Double(NSEC_PER_SEC))) // 1    dispatch_after(popTime, GlobalMainQueue) { // 2    let count = PhotoManager.sharedManager.photos.count    if count > 0 {     self.navigationItem.prompt = nil    } else {     self.navigationItem.prompt = "Add photos with faces to Googlyify them!"    }   }  }

當你的 UICollectionView 重載時,viewDidLoad 裡的 showOrHideNavPrompt 就會被執行。說明如下:

  1. 宣告一個代表延遲秒數的變數。

  2. 等待 delayInSeconds 指定的時間後,向主佇列非同步加入閉包。

編譯執行,你會看到一個恰到好處的小延遲,有效地提醒用戶該做什麼。

dispatch_after 就像一個延遲版的 dispatch_async。你依然無法在它執行期間介入,而且一旦 dispatch_after 回傳,也無法取消整個延遲任務。

還在糾結 dispatch_after 該怎麼用?

  • 自訂序列佇列:在上面用 dispatch_after 要小心,通常不建議這麼做。

  • 主佇列(序列):對 dispatch_after 來說是很好的選擇,Xcode 也有現成的範本。

  • 並發佇列:同樣要小心,雖然你大概很少這麼做,最好還是改到主佇列上執行。

單例與執行緒安全

單例不管你愛它還是恨它,在 iOS 開發裡都舉足輕重。

一提到單例,很多人馬上想到「執行緒不安全」。這麼想不是沒道理:單例實例往往會在同一時間被多條執行緒存取。PhotoManager 就是一個單例,所以上面提到的問題都值得想一想。

需要考慮兩種情況:實例初始化時的執行緒安全,以及實例讀寫時的執行緒安全。

先看第一種。因為 Swift 在全域範圍初始化變數,這種情況相對簡單:Swift 的全域變數在首次被存取時完成初始化,而且整個初始化過程具原子性。因此初始化程式碼本身就構成一個臨界區,並在其他執行緒存取該全域變數之前完成。Swift 怎麼做到的?其實它內部就是靠 dispatch_once 使用了 GCD。想深入了解可以參考 Swift 官方 Blog。

在執行緒安全的保證下,dispatch_once 只會執行閉包一次。當某條在臨界區內的執行緒把任務交給 dispatch_once 時,其他執行緒在它跑完之前都會被擋住;一旦執行完成,就不會再有人進入這段區域。用 let 把單例定義成全域定量,我們就能保證它的值初始化之後不會被改動。總之,Swift 宣告的所有全域定量,都是透過執行緒安全的初始化取得的單例。

但我們還得考慮讀寫。Swift 用 dispatch_once 確保了單例的初始化是執行緒安全的,但這不代表單例的資料型別同樣安全。舉例來說,如果某個全域變數是一個類別的實例,你依然可以在那個類別的臨界區裡操作內部資料,這就需要另外的手段來保證安全。

處理讀取與寫入

保證實例化時的執行緒安全,並不是處理單例的唯一課題。如果單例的某個屬性代表一個可變物件,比如 PhotoManager 裡的 photos 陣列,那你就得 considers 那個物件本身是否具備執行緒安全。

在 Swift 中,用 let 宣告的變數是唯讀且執行緒安全的常量;用 var 宣告的則可變且執行緒不安全。像 Array、Dictionary 這種集合型別,一旦被宣告為可變,它就是執行緒不安全的。那 Foundation 裡的 NSArray 呢?不一定!Apple 還專門為那些執行緒非安全的 Foundation 類別列了一份清單。

多執行緒在不出問題的情況下同時讀取一個 Array 的可變實例是可以的;但當一條執行緒想修改它、另一條同時想讀取,安全性就無法保證了。

看看 PhotoManager.swift 的 addPhoto 函式,找找問題在哪:

func addPhoto(photo: Photo) {   _photos.append(photo)   dispatch_async(dispatch_get_main_queue()) {     self.postContentAddedNotification()   } }

這個寫入方法直接改動了可變陣列。

再看 photos 這個 property:

private var _photos: [Photo] = [] var photos: [Photo] {   return _photos }

getter 讀取可變陣列的這一步,就是一個讀取函式。呼叫者拿到的是陣列的一份 copy,能避免原陣列被不當修改,但這並不能阻止一條執行緒呼叫 addPhoto 的同時,另一條執行緒去呼叫 photos 的 getter。

補充:為什麼呼叫者拿到的不是同一份 photos?因為 Swift 中所有參數與回傳值都是以參考(reference)或值的方式傳遞。以參考傳遞等同於 Objective-C 傳指標,你可以存取原始物件,對它的任何改動都會被看到;以值傳遞則是傳 copy,對 copy 的改動不影響原物件。Swift 預設以參考傳遞類別實例,結構體則以值傳遞。

Swift 的 Array 與 Dictionary 都是用結構體實作的,來回傳遞這些實例時,程式碼看似做了很多次 copy。這時不必擔心記憶體問題,因為這些集合型別的實作都經過優化,只在必要時才真的複製。對一個以值傳遞的 Array 實例來說,只有在第一次被修改時才會發生真正的複製。

這是軟體開發裡典型的讀寫問題,而 GCD 用 dispatch barrier 提供了一個近乎完美的讀/寫鎖方案。

在並發佇列上使用時,dispatch barrier 就像一道暫時的柵欄。GCD 的 barrier API 保證被傳入的閉包在特定時間內是該佇列上唯一執行的任務,也就是說,barrier 之前派發的任務必須全部跑完,這個閉包才能開始。

閉包一抵達,barrier 就開始執行它,並保證這段時間內佇列不會再跑任何別的閉包;這個閉包一結束,佇列就回到原本的並發狀態。GCD 也提供了同步與非同步兩種 barrier 函式。

下圖描述多個非同步任務中 barrier 的運作:

dispatch barrier

注意 barrier 執行前程式是以並發佇列的形式在跑,而 barrier 一開始,程式就以序列佇列的形式運行——沒錯,barrier 就是那段時間內唯一被執行的任務;等它結束,程式又回到普通的並發佇列狀態。

關於 barrier,有幾點提醒:

  • 自訂序列佇列:不建議在這種情況下用 barrier,因為它在序列佇列執行期間起不了任何作用。

  • 全域並發佇列:謹慎使用。其他系統元件也在用這些佇列,你應該不想把它們都佔為己有。

  • 自訂並發佇列:適合處理涉及臨界區與原子性的程式碼。任何需要保證設定或初始化具執行緒安全的場合,barrier 都是好選擇。

從上面的說明可以推出一個結論:你得自己寫一個 barrier 函式,並把讀取與寫入分開處理,讓並發佇列允許複數讀取同時進行。

打開 PhotoManager.swift,在 photos 屬性下方加入這個私有屬性:

private let concurrentPhotoQueue = dispatch_queue_create(     "com.raywenderlich.GooglyPuff.photoQueue", DISPATCH_QUEUE_CONCURRENT)

這裡用 dispatch_queue_create 建立了一個名為 concurrentPhotoQueue 的並發佇列。第一個參數是反向 DNS 風格的名稱,除錯時很有用;第二個參數決定佇列是序列還是並發。

網路上很多範例喜歡把第二個參數寫成 0 或 NULL,那是宣告序列佇列的舊寫法,建議還是用明確的參數。

找到 addPhoto,替換成:

func addPhoto(photo: Photo) {   dispatch_barrier_async(concurrentPhotoQueue) { // 1     self._photos.append(photo) // 2     dispatch_async(GlobalMainQueue) { // 3       self.postContentAddedNotification()     }   } }

新函式的運作方式:

  1. 透過自訂佇列進行寫入,稍後進入臨界區時,這會是佇列中唯一執行的任務。

  2. 把物件加進陣列。只要是 barrier 閉包,它在 concurrentPhotoQueue 中絕不會與其他閉包同時執行。

  3. 最後推送照片已加入的訊息。這個訊息涉及 UI 相關工作,必須從主執行緒發出,所以以非同步方式派到主佇列。

寫入這邊處理好了,接著處理 photos 的讀取。

為了維持寫入端的執行緒安全,讀取也必須在 concurrentPhotoQueue 上執行。但讀取需要回傳值,而且我們希望讀取任務跑完前不要有其他任務插入,所以不能對佇列做非同步派發。

這種情況下,dispatch_sync 就是合適的選擇。

dispatch_sync 會同步送出任務並等它完成後才回傳。搭配帶 barrier 的任務,或需要等任務跑完才能取用閉包中資料的場合,都適合用 dispatch_sync。

但務必謹慎。想像一下,如果你對一個即將要跑的佇列呼叫 dispatch_sync,就會造成死鎖:呼叫方得等閉包 B 跑完才能繼續,而閉包 B 又得等當前那個永遠結束不了的閉包 A 結束,才有機會執行。

所以你必須時時留意自己呼叫的、或傳入的究竟是哪個佇列。

dispatch_sync 的使用建議:

  • 自訂序列佇列:一定要非常小心。如果佇列裡正在跑任務,而你把它傳進 dispatch_sync,幾乎必然死鎖。

  • 主佇列(序列):同樣要小心死鎖。

  • 並發佇列:需要同步執行 barrier 任務,或必須等某個任務結束才能繼續下一步時,dispatch_sync 是好選擇。

同樣在 PhotoManager.swift 中,把 photos 屬性替換成:

var photos: [Photo] {   var photosCopy: [Photo]!   dispatch_sync(concurrentPhotoQueue) { // 1     photosCopy = self._photos // 2   }   return photosCopy }

說明:

  1. 同步派發到 concurrentPhotoQueue 執行讀取。

  2. 把照片陣列存進 photosCopy 並回傳。

恭喜——你的 PhotoManager 單例現在是執行緒安全的了。不論讀還是寫,都能保證整個單例在安全模式下運行。

把佇列看出來

還沒完全掌握 GCD 的基礎?接下來我們用一個簡單的示例,透過斷點和 NSLog 讓你更直觀地理解這些函式的行為。

我會用兩張動態 GIF 說明 dispatch_async 與 dispatch_sync,注意每一步切換時,程式碼斷點與圖示之間的對應關係。

dispatch_sync 回顧

override func viewDidLoad() {   super.viewDidLoad()   dispatch_sync(dispatch_get_global_queue(       Int(QOS_CLASS_USER_INTERACTIVE.value), 0)) {     NSLog("First Log")   }   NSLog("Second Log") }

dispatch_sync

逐步說明:

  1. 主佇列依序執行任務,下一個待執行的就是實例化含 viewDidLoad 的 UIViewController。

  2. 主佇列開始執行 viewDidLoad。

  3. dispatch_sync 的閉包被加入全域佇列,稍後執行。在這個閉包完成前,主佇列的工作會被暫停。全域佇列是並發的,閉包以 FIFO 順序加入,而這個佇列裡原本已經排著好幾個任務。

  4. 終於輪到 dispatch_sync 的閉包執行。

  5. 閉包執行完畢,主佇列恢復工作。

  6. viewDidLoad 結束,主佇列開始處理其他任務。

dispatch_sync 向佇列加入一個任務並等它完成。dispatch_async 其實差不多,只是它不會等任務結束就回傳。

dispatch_async 回顧

override func viewDidLoad() {   super.viewDidLoad()   dispatch_async(dispatch_get_global_queue(       Int(QOS_CLASS_USER_INTERACTIVE.value), 0)) {     NSLog("First Log")   }   NSLog("Second Log") }

dispatch_async

  1. 主佇列依序執行任務,下一個待執行的就是實例化含 viewDidLoad 的 UIViewController。

  2. 主佇列開始執行 viewDidLoad。

  3. dispatch_async 的閉包被加入全域佇列,稍後執行。

  4. 加入閉包後 viewDidLoad 繼續往下跑,主執行緒完成剩餘工作;與此同時,全域佇列以其並發的方式處理自己的任務,可並發執行的閉包以 FIFO 順序加入。

  5. 透過 dispatch_async 加入的閉包開始執行。

  6. 閉包執行結束,所有 NSLog 都出現在控制台上。

這個例子裡,第二個 NSLog 反而先執行。這並非每次都會發生——取決於硬件在該時間點忙於什麼,而你對哪一句會先跑既無知也無從控制。搞不好「第一個」NSLog 真的會是第一個出現在 log 裡的那句。

Where to Go From Here?

在這篇教程中,你學會了如何讓程式碼具備執行緒安全,以及在 CPU 高負載、多任務並行時保持主執行緒的響應。

你可以從這裡下載 GooglyPuff 的完整程式碼,下一節教程會繼續在這個專案上做修改。

如果你打算優化自己的 App,我真心建議你試試 Instruments 的 Time Profiler,具體做法可以參考 How To Use Instruments。

下一節教程裡,你會用更進階的 GCD API 做一些更有意思的事。

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