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怎么实现？
全局变量的初始化闭包中写只执行一次的代码
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
}
}
