GCD系列 一 使用DispatchWorkItem (3)

DispatchWorkItem

DispatchWorkItem是封装work的对象，可以监听work完成的通知，并指定和其他DispatchWorkItem之间的依赖关系。

A DispatchWorkItem encapsulates work to be performed on a dispatch queue or within a dispatch group. You can also use a work item as a DispatchSource event, registration, or cancellation handler.

DispatchWorkItem结构

DispatchWorkItem 是一个Class， 含有一个 实例变量表示任务是否被取消

var isCancelled: Bool

同时，你可以调用 DispatchWorkItem 的取消方法

func cancel()
Cancels the current work item asynchronously.

• 如果任务放入队列中，在任务执行之前调用了cancel()， 那么这个任务将不会被Queue执行
• 如果任务已经在执行中了， 调用了cancel()， 那么将直接终止任务的执行

DispatchWorkItem 实践

• 异步执行work

let work1 = DispatchWorkItem {
    print("Simple Pure Work")
}
DispatchQueue.global().async(execute: work1)

• 同步执行work

let work1 = DispatchWorkItem {
   print("Simple Pure Work")
}
DispatchQueue.global().sync(execute: work1)

• 创建带QoS的workItem

let work2 = DispatchWorkItem(qos: .background) {
    print("Work background")
}

let work3 = DispatchWorkItem(qos: .userInteractive) {
    print("Work userInteractive")
}

DispatchQueue.global().async(execute: work2)
DispatchQueue.global().async(execute: work3)

work3将先执行

• 创建带Flags的workItem, barrier表示作为屏障，在此之前的work必须先执行完后，当前work才开始执行；只有当当前work结束后，后续提交的work才能够继续执行
• 注意，如果这里的queue是global队列，将无法达到效果

let work2 = DispatchWorkItem(qos: .default, flags: .enforceQoS) {
    print("work2")
}

let work3 = DispatchWorkItem(qos: .default, flags: .barrier) {
    Thread.sleep(forTimeInterval: 3)
    print("work3")
}
let work4 = DispatchWorkItem(qos: .default) {
    print("work4")
}

let q = DispatchQueue(label: "concurrent", attributes: .concurrent)
q.async(execute: work2)
q.async(execute: work3)
q.async(execute: work4)

• 创建带Flags的workItem

/*
 public static let barrier: DispatchWorkItemFlags

 @available(macOS 10.10, iOS 8.0, *)
 public static let detached: DispatchWorkItemFlags

 @available(macOS 10.10, iOS 8.0, *)
 public static let assignCurrentContext: DispatchWorkItemFlags

 @available(macOS 10.10, iOS 8.0, *)
 public static let noQoS: DispatchWorkItemFlags

 @available(macOS 10.10, iOS 8.0, *)
 public static let inheritQoS: DispatchWorkItemFlags

 @available(macOS 10.10, iOS 8.0, *)
 public static let enforceQoS: DispatchWorkItemFlags
 */
/// 强制使用当前work的QoS
let work2 = DispatchWorkItem(qos: .default, flags: .enforceQoS) {
    print("work2")
}
/// inheritQoS 继承队列的QoS
let work3 = DispatchWorkItem(qos: .default, flags: .inheritQoS) {
    Thread.sleep(forTimeInterval: 3)
    print("work3")
}
/// work执行的时候使用当前的上下文？（具体有点不清晰）
let work4 = DispatchWorkItem(qos: .default, flags: .assignCurrentContext) {
    print("work4")
}

let q = DispatchQueue(label: "concurrent", attributes: .concurrent)
q.async(execute: work2)
q.async(execute: work3)
q.async(execute: work4)

• WorkItem之间的同步，下面的两个任务将等待第一个任务5s后执行完才执行

let work = DispatchWorkItem {
    print("work start")
    Thread.sleep(forTimeInterval: 5)
}
work.notify(queue: .main) {
    print("work done")
}
work.notify(queue: .global(), execute: DispatchWorkItem(block: {
    print("work item done")
}))
DispatchQueue.global().async(execute: work)

• wait方法

let queue = DispatchQueue(label: "queue", attributes: .concurrent)
let workItem = DispatchWorkItem {
    sleep(3)
    print("done")
}
    
queue.async(execute: workItem)
print("before waiting")
workItem.wait()
print("after waiting")