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