前言
这是一篇仿写的博客,主要目的是熟悉Swift3+GCD.
参考博客.
一次就好?
我们知道ARC普及后 Objective-C 中单例的实现大多是用 dispatch_once 实现的.
但是在Swift中是不是这样呢?我们很少看到这样的实现.
Swift中 static var 变量内部已经采用 dispatch_once 实现.
详见官方文档
延时执行
延时执行有多种方式, NSObject 中有 |performSelector:withObject:afterDelay| 及 NSTimer.
GCD中有 dispatch_after.
很多时候我们为了规避某种时序问题, 往往会比较草率的加一个延时操作. 比如延时n秒做一些释放资源的操作.
这样虽然解决了一些bug, 但是也引入了一些不确定性.
有一个地方需要注意下, 因为延时执行的block会 retain self, 如果延时的时间较长,
那么 block 使用 self 需要弱引用下.
// 延时1s执行
DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
print("hello world after 1s.")
}
队列
队列我们也经常使用, 主要接触的队列有两种, 一个是 main queue(串行队列), 一个是 global queue(并行队列).
我们也可以创建自己的队列便于对操作进行管理. 默认情况下创建的队列是串行队列.
串行队列一次只允许一个block任务执行, 并行队列一次允许多个block任务同时执行.
// 串行队列
let syncQueue = DispatchQueue(label: "demo.sync_queue")
// 并行队列
let asyncQueue = DispatchQueue(label: "demo.async_queue", qos: .default, attributes: .concurrent, autoreleaseFrequency: .inherit, target: nil)
目标队列
通常我们创建队列的时候不会特意指定一个目标队列. 那么什么情况下会使用目标队列呢?
想象下如下场景, 我们一个模块有一个总的队列叫做 moduleQueue, 然后具体的类里面自己管理自己的队列叫 classQueue,
但是为了便于管理, 所有的 classQueue 都指定目标队列为 moduleQueue.
那么模块中的moduleQueue就会统一调度整个模块内的 classQueue.
队列优先级
通常我们不会去设置队列的优先级, default 优先级足以使用了.
但是某些情况比如io操作会阻塞队列, 这种情况下我们可以将io操作的优先级调低以保证其他操作在队列中优先执行.
但是设置优先级的行为比较危险的, 一旦出现优先级反转的情况, 会产生不可预知的后果.
隔离
隔离队列是 GCD 队列使用中非常普遍的一种模式
资源保护
之前的博客中我们使用 GCD 简单的实现了一个读写锁.
这里我们用Swift3再实现一遍.
let asyncQueue = DispatchQueue(label: "demo.async_queue", qos: .default, attributes: .concurrent)
var number: Int = 0
func singleWrite(num: Int) {
asyncQueue.async(flags: .barrier) {
number = num
}))
}
func mutiRead() -> Int {
var tempNum = 0
asyncQueue.sync {
tempNum = number
}
return tempNum
}
迭代执行
这个不多说了, 比较下下面两段代码:
// for 循环
for _ in 0..<100 {
DispatchQueue.global().async {
print("\(Thread.current)")
}
}
// 迭代执行
DispatchQueue.global().async {
DispatchQueue.concurrentPerform(iterations: 100) { _ in
print("\(Thread.current)")
}
}
组
顾名思义就是将一组操作组合到一起完成一个任务, 这些操作可以是串行的也可以是并行的.
let group = DispatchGroup()
asyncQueue.async(group: group) {
print("\(Thread.current),async - group")
sleep(1)
}
group.enter()
asyncQueue.async {
print("\(Thread.current),enter - leave")
sleep(1)
group.leave()
}
// wait until all blocks in group are done.
group.wait()
print("one more time.")
asyncQueue.async(group: group) {
print("\(Thread.current),async - group")
sleep(1)
}
group.enter()
asyncQueue.async {
print("\(Thread.current),enter - leave")
sleep(1)
group.leave()
}
// when all blocks in group are done, just notify
group.notify(queue: DispatchQueue.global()) {
print("over ...")
}
事件源
timer
dispatch_source_t 个人用的比较多的是自定义timer,因为NSTimer有循环引用的风险.
dispatch_after 又不能中途cancel掉.
let timer = DispatchSource.makeTimerSource()
timer.scheduleOneshot(deadline: .now() + 2)
timer.setEventHandler {
print("handle event")
}
timer.setCancelHandler {
print("cancel")
}
timer.resume()
监视文件
这个使用技巧最早是在Apple的Demo Lister 中有看见过,
DirectoryMonitor类中用来监测文件夹内容是否发生变化, 从而同步数据 Apple Watch 和 iPhone 的数据源.
// 这里是我桌面的文件夹,大家测试的时候可以指定自己的文件夹
let fileURL = URL(fileURLWithPath: "/Users/cxjwin/Desktop/Docs"/*file path string*/)
let monitoredDirectoryFileDescriptor = open(fileURL.path, O_EVTONLY)
let directoryMonitorSource = DispatchSource.makeFileSystemObjectSource(fileDescriptor: monitoredDirectoryFileDescriptor, eventMask: .write)
directoryMonitorSource.setEventHandler {
print("change file")
}
directoryMonitorSource.setCancelHandler {
close(monitoredDirectoryFileDescriptor)
}
directoryMonitorSource.resume();
监视进程
这个估计只有Mac开发的时候才能用上了
// 监测邮件应用的退出
var processSource: DispatchSourceProcess! = nil
let apps = NSRunningApplication.runningApplications(withBundleIdentifier: "com.apple.mail")
let processIdentifier = apps.first?.processIdentifier
if let pid = processIdentifier {
processSource = DispatchSource.makeProcessSource(identifier: pid, eventMask: .exit)
processSource.setEventHandler {
print("email exit")
}
processSource.resume()
}
输入输出
异步读
let asyncQueue = DispatchQueue(label: "demo.async_queue", qos: .default, attributes: .concurrent)
let fileURL = URL(fileURLWithPath: "/Users/cxjwin/Desktop/duty.md"/*file path string*/)
let fileDescriptor = open(fileURL.path, O_RDWR)
DispatchIO.read(fromFileDescriptor: fileDescriptor, maxLength: -1, runningHandlerOn: asyncQueue) {
(data, num) -> Void in
print("thread : \(Thread.current), data length : \(data.count), return value : \(num)")
// 调用下面的异步写
demoIOWrite(data: data)
}
异步写
func demoIOWrite(data: DispatchData) {
// 这里是我桌面的文件(文件必须先存在,这里创建一个空文件),大家测试的时候可以指定自己的文件
let fileURL = URL(fileURLWithPath: "/Users/cxjwin/Desktop/hello.md"/*file path string*/)
let fileDescriptor = open(fileURL.path, O_RDWR)
DispatchIO.write(toFileDescriptor: fileDescriptor, data: data, runningHandlerOn: asyncQueue) {
(data, num) -> Void in
print("thread : \(Thread.current), data length : \(data), return value : \(num)")
}
}
总结
以上是 Swift3 调用 GCD 的一些简单的示例, 和之前 Objective-C 上面的调用还是有些不一样的.
刚开始熟悉的时候还是比较别扭的. 最后附上自己的 Demo 以供参考.
注意, Demo只支持Swift3, 所以在 Xcode8 下面运行.
