Swift - 多線程實現方式 - Grand Central Dispatch（GCD）

1，Swift繼續使用Object-C原有的一套線程，包括三種多線程編程技術：
（1）Thread
（2）Cocoa Operation（Operation和OperationQueue）
（3）Grand Central Dispath（GCD）

2，本文着重介紹Grand Central Dispath（GCD）

GCD是Apple開發的一個多核編程的解決方法，基本概念就是dispatch queue（調度隊列），queue是一個對象，它可以接受任務，並將任務以先到先執行的順序來執行。dispatch queue可以是並發的或串行的。GCD的底層依然是用線程實現，不過我們可以不用關注實現的細節。其優點有如下幾點：

（1）易用：GCD比thread更簡單易用。基於block的特效使它能極為簡單地在不同代碼作用域之間傳遞上下文。

（2）效率：GCD實現功能輕量，優雅，使得它在很多地方比專門創建消耗資源的線程更加實用且快捷。

（3）性能：GCD自動根據系統負載來增減線程數量，從而減少了上下文切換並增加了計算效率。

（4）安全：無需加鎖或其他同步機制。

本文代碼已全部更新至Swift3。

 

3，GCD三種創建隊列的方法

（1）自己創建一個隊列

第一個參數代表隊列的名稱，可以任意起名

第二個參數代表隊列屬於串行還是並行執行任務

串行隊列一次只執行一個任務。一般用於按順序同步訪問，但我們可以創建任意數量的串行隊列，各個串行隊列之間是並發的。

並行隊列的執行順序與其加入隊列的順序相同。可以並發執行多個任務，但是執行完成的順序是隨機的。

//創建串行隊列
let serial = DispatchQueue(label: "serialQueue1")
 
//創建並行隊列
let concurrent = DispatchQueue(label: "concurrentQueue1", attributes: .concurrent)

（2）獲取系統存在的全局隊列 

Global Dispatch Queue有4個執行優先級：

.userInitiated  高

.default  正常

.utility  低

.background 非常低的優先級（這個優先級只用於不太關心完成時間的真正的后台任務）

 

let globalQueue = DispatchQueue.global(qos: .default)

（3）運行在主線程的Main Dispatch Queue 

正如名稱中的Main一樣，這是在主線程里執行的隊列。因為主線程只有一個，所有這自然是串行隊列。一起跟UI有關的操作必須放在主線程中執行。

let mainQueue = DispatchQueue.main

4，添加任務到隊列的兩種方法 

（1）async異步追加Block塊（async函數不做任何等待）

DispatchQueue.global(qos: .default).async {
    //處理耗時操作的代碼塊...
    print("do work")
     
    //操作完成，調用主線程來刷新界面
    DispatchQueue.main.async {
        print("main refresh")
    }
}

（2）sync同步追加Block塊 

同步追加Block塊，與上面相反。在追加Block結束之前，sync函數會一直等待，等待隊列前面的所有任務完成后才能執行追加的任務。

//添加同步代碼塊到global隊列
//不會造成死鎖，但會一直等待代碼塊執行完畢
DispatchQueue.global(qos: .default).sync {
    print("sync1")
}
print("end1")
 
 
//添加同步代碼塊到main隊列
//會引起死鎖
//因為在主線程里面添加一個任務，因為是同步，所以要等添加的任務執行完畢后才能繼續走下去。但是新添加的任務排在
//隊列的末尾，要執行完成必須等前面的任務執行完成，由此又回到了第一步，程序卡死
DispatchQueue.main.sync {
    print("sync2")
}
print("end2")

5，暫停或者繼續隊列

這兩個函數是異步的，而且只在不同的blocks之間生效，對已經正在執行的任務沒有影響。

suspend()后，追加到Dispatch Queue中尚未執行的任務在此之后停止執行。

而resume()則使得這些任務能夠繼續執行。

//創建並行隊列
let conQueue = DispatchQueue(label: "concurrentQueue1", attributes: .concurrent)
//暫停一個隊列
conQueue.suspend()
//繼續隊列
conQueue.resume()

6，只執行一次

過去dispatch_once中的代碼塊在應用程序里面只執行一次，無論是不是多線程。因此其可以用來實現單例模式，安全，簡潔，方便。

//往dispatch_get_global_queue隊列中添加代碼塊，只執行一次
var predicate:dispatch_once_t = 0
dispatch_once(&predicate, { () -> Void in
    //只執行一次，可用於創建單例
    println("work")
})

在Swift3中，dispatch_once被廢棄了，我們要替換成其他全局或者靜態變量和常量.

private var once1:Void = {
    //只執行一次
    print("once1")
}()
 
private lazy var once2:String = {
    //只執行一次，可用於創建單例
    print("once2")
    return "once2"
}()

7，asyncAfter 延遲調用

asyncAfter 並不是在指定時間后執行任務處理，而是在指定時間后把任務追加到queue里面。因此會有少許延遲。注意，我們不能（直接）取消我們已經提交到 asyncAfter 里的代碼。

//延時2秒執行
DispatchQueue.global(qos: .default).asyncAfter(deadline: DispatchTime.now() + 2.0) {
    print("after!")
}

如果需要取消正在等待執行的Block操作，我們可以先將這個Block封裝到DispatchWorkItem對象中，然后對其發送cancle，來取消一個正在等待執行的block。

//將要執行的操作封裝到DispatchWorkItem中
let task = DispatchWorkItem { print("after!") }
//延時2秒執行
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 2, execute: task)
//取消任務
task.cancel()

8，多個任務全部結束后做一個全部結束的處理

async(group:)：用來監視一組block對象的完成，你可以同步或異步地監視

notify()：用來匯總結果，所有任務結束匯總，不阻塞當前線程

wait()：等待直到所有任務執行結束，中途不能取消，阻塞當前線程

//獲取系統存在的全局隊列
let queue = DispatchQueue.global(qos: .default)
//定義一個group
let group = DispatchGroup()
//並發任務，順序執行
queue.async(group: group) {
    sleep(2)
    print("block1")
}
queue.async(group: group) {
    print("block2")
}
queue.async(group: group) {
    print("block3")
}
 
//1,所有任務執行結束匯總，不阻塞當前線程
group.notify(queue: .global(), execute: {
    print("group done")
})
 
//2,永久等待，直到所有任務執行結束，中途不能取消，阻塞當前線程
group.wait()
print("任務全部執行完成")

9，concurrentPerform 指定次數的Block最加到隊列中

DispatchQueue.concurrentPerform函數是sync函數和Dispatch Group的關聯API。按指定的次數將指定的Block追加到指定的Dispatch Queue中，並等待全部處理執行結束。

因為concurrentPerform函數也與sync函數一樣，會等待處理結束，因此推薦在async函數中異步執行concurrentPerform函數。concurrentPerform函數可以實現高性能的循環迭代。

//獲取系統存在的全局隊列
let queue = DispatchQueue.global(qos: .default)
 
//定義一個異步步代碼塊
queue.async {
    //通過concurrentPerform，循環變量數組
    DispatchQueue.concurrentPerform(iterations: 6) {(index) -> Void in
        print(index)
    }
     
    //執行完畢，主線程更新
    DispatchQueue.main.async {
        print("done")
    }
}

10，信號，信號量

DispatchSemaphore(value: )：用於創建信號量，可以指定初始化信號量計數值，這里我們默認1.

semaphore.wait()：會判斷信號量，如果為1，則往下執行。如果是0，則等待。

semaphore.signal()：代表運行結束，信號量加1，有等待的任務這個時候才會繼續執行。

//獲取系統存在的全局隊列
let queue = DispatchQueue.global(qos: .default)
 
//當並行執行的任務更新數據時，會產生數據不一樣的情況
for i in 1...10 {
    queue.async {
        print("\(i)")
    }
}
 
//使用信號量保證正確性
//創建一個初始計數值為1的信號
let semaphore = DispatchSemaphore(value: 1)
for i in 1...10 {
    queue.async {
        //永久等待，直到Dispatch Semaphore的計數值 >= 1
        semaphore.wait()
        print("\(i)")
        //發信號，使原來的信號計數值+1
        semaphore.signal()
    }
}

 

原文出自：www.hangge.com  轉載請保留原文鏈接：http://www.hangge.com/blog/cache/detail_745.html