Swift-GCD使用

1. DispatchTime和DispatchWallTime的區別？

例如: 從現在開始,1小時之後是觸發某個事件
DispatchTime函數創建的是一個相對的時間, 參考的是當前系統的時鐘。當 device 進入休眠之後,系統的時鐘也會進入休眠狀態，事件的實際觸發是從喚醒 device 的時刻繼續計時的。
DispatchWallTime創建的是一個絕對的時間點,一旦創建就表示從這個時間點開始,1小時之後觸發事件,假如 device 休眠了10分鐘,當再次喚醒 device 的時候不會受到 device 是否進入休眠影響。

DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
    print("2秒後執行")
}
DispatchQueue.main.asyncAfter(wallDeadline: .now() + 2) {
    print("2秒後執行")
}

2. 串行、並行、全局隊列創建

let serialQueue = DispatchQueue(label: "com.serial.xxx")
let concurrentQueue = DispatchQueue(label: "com.concurrent.xxx", attributes: [.concurrent])
let globalQueue = DispatchQueue.global()
let mianQueue = DispatchQueue.mian

3. 同步、異步任務執行

queue.async {
    print("異步")
}
queue.sync {
    print("同步")
}

4. DispatchWorkItem的使用

上面的同步、異步任務是包裝在closure的，其實初始化DispatchWorkItem作爲任務。如果需要對任務的狀態進行監聽和控制可以使用它，如下：

let item = DispatchWorkItem {
    print("DispatchWorkItem----")
}
queue.async(execute: item)
item.notify(queue: DispatchQueue.main) {
    print("item已經執行完了")
}

5. 定時器

var globalTimer: DispatchSourceTimer?
func testGCDTimer() {
    let queue = DispatchQueue.init(label: "zlq")
    
    let timer = DispatchSource.makeTimerSource(queue: queue)
    timer.setEventHandler {// timer到時時觸發block
        print("timer event handler---")
    }
    
    timer.setCancelHandler {// timer取消時回調
        print("timer cancle---")
    }
    
    let timerItem = DispatchWorkItem {
        print("timerItem")
    }
    
    print("timer初始化---")
    // deadline是第一次觸發時間，後續每隔repeating時間重複一次，如果只執行一次則不需要repeating參數
    timer.schedule(deadline: .now() + 1, repeating: 2)
    globalTimer = timer
    
    // 啓動定時器
    timer.resume()
    
    // 10秒後取消timer
    DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
        globalTimer?.cancel()
        globalTimer = nil
    }
}

6. 組隊列

比較適用的場景：多個異步任務，需要在任務都完成時執行刷新邏輯。
方法一：

//創建隊列組常量(這是個全局常量)
let group = DispatchGroup()

// 任務1
let queue = DispatchQueue.global()
self.group.enter()
queue.async {
    self.group.leave() //不管成功與否都要leave()操作,方便後面的請求繼續進行
}

// 任務2
self.group.enter()
queue.async {
    self.group.leave()
}

// 組隊列中的人物都執行完畢了會來到這裏
group.notify(queue: DispatchQueue.main) {
    self.tableView.reloadData()
}

方法二：

let group = DispatchGroup()
let queue = DispatchQueue(label: "com.concurrent.zlq", attributes: [.concurrent])
func testGroup() {
    
    queue.async(group: group) {
        usleep(1000)
        print("任務一")
    }
    
    queue.async(group: group) {
        usleep(500)
        print("任務二")
    }
    
    group.notify(queue: DispatchQueue.main) {
        print("group.notify===thread=\(Thread.current)")
    }
}

7. 柵欄任務

func testGCDBarrier() {
    let queue = DispatchQueue(label: "com.zlq.concurrent", attributes: .concurrent)
    
    for i in 1..<100 {
        queue.async {
            print("併發隊列異步任務\(i)", Thread.current)
            if i % 10 == 0 {
                Thread.sleep(forTimeInterval: 1)
                queue.async {
                    print("併發隊列異步任務\(i)==\(i)")
                }
            }
        }
    }
    
    // 柵欄函數的closure任務會等queue中前面的所有任務執行完再執行，
    // 同時比柵欄任務更晚添加到queue中的任務需要等柵欄任務執行完纔會執行。
    queue.async(flags: .barrier) {
        Thread.sleep(forTimeInterval: 5)
    }
    
    print("柵欄函數異步任務下一步") // 這一步不需要柵欄函數執行後才執行
}

8. 信號量

需要GCD控制最大併發數量的時候，使用信號量是比較合適的。

let semaphore = DispatchSemaphore(value: 2)// 最大併發數=2
func testSemaphore() {
    let queue = DispatchQueue(label: "com.zlq.concurrent", attributes: .concurrent)

    queue.async {
        // 等待信號量，信號量>1或者等待時間超過5秒時可以執行
        let result = semaphore.wait(timeout: .now() + 5)
        
        if result == .success {
            print("執行任務一：-----")
            sleep(6)
        } else {
            print("任務一：等待超時-----")
        }
    }
    
    queue.async {
        // 等待信號量，信號量>1或者等待時間超過5秒時可以執行
        let result = semaphore.wait(timeout: .now() + 5)
        // 執行時信號量-1
        if result == .success {
            print("執行任務二：-----")
            sleep(6)
            semaphore.signal() // 信號量+1
        } else {
            print("任務二：等待超時-----")
        }
    }
    
    // 任務一、二因爲有信號量可以直接執行，任務三需等待信號量.
    // 下面的任務三在等待5秒後，超時執行
    queue.async {
        // 等待信號量，信號量>1或者等待時間超過5秒時可以執行
        let result = semaphore.wait(timeout: .now() + 5)
        // 執行時信號量-1
        if result == .success {
            print("執行任務三：-----")
            sleep(6)
            semaphore.signal() // 信號量+1
        } else {
            print("任務三：等待超時-----")
        }
    }
}

9. OC中的Dispatch_once怎麼實現？

Swift-實現dispatch_once效果

全局變量的初始化閉包中寫只執行一次的代碼
let dispatchOnce: () = {
    print("dispatchOnce-------")
}()
// 調用一次
_ = dispatchOnce

10. 判斷當前是否主隊列

因爲主隊列中任務一定是主線程執行，但是主線程執行的任務有可能是非主隊列中的，而有的情況下是要求主隊列 + 主線程執行，比如：

在 ReactiveCocoa 的一個 issue裏提到在MapKit 中的 MKMapView 有個 addOverlay 方法，這個方法不僅要在主線程中執行，而且要把這個操作加到主隊列中才可以，並且後來 Apple DTS 也承認了這是一個bug。

// OC版本，SDWebImage中的宏
// 判斷回調到主線程執行的方式：dispatch_queue_get_label
#ifndef dispatch_main_async_safe
#define dispatch_main_async_safe(block)\
    if (dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL) == dispatch_queue_get_label(dispatch_get_main_queue())) {\
        block();\
    } else {\
        dispatch_async(dispatch_get_main_queue(), block);\
    }
#endif
    
 // Swift版本，以下RxSwift中的方式:
 // 判斷當前執行的上下文中是否存在關聯key的值，該key只設定在主隊列的上下文中
 extension DispatchQueue {
     // DispatchSpecificKey: 與調度隊列上的特定上下文值關聯的鍵。
    private static var token: DispatchSpecificKey<()> = {
        let key = DispatchSpecificKey<()>()
        DispatchQueue.main.setSpecific(key: key, value: ())
        return key
    }()
    static var isMain: Bool {
        // getSpecific:返回當前執行的上下文關聯key對應的值
        DispatchQueue.getSpecific(key: token) != nil
    }
}