Swift中的异步编程方式
Swift中的异步编程方式
引
说到异步编程，我们很容易想到的编译回调。无论是需要并行的耗时任务，还是允许串行的简单任务，都通过回调的方式返回结果。回调也是在开发中使用最为广泛的一种异步编程方式。回想一下，通常的网络请求，文件操作等函数都会提供一个回调参数。回调使用起来虽然方便，但其并不利于进行程序流程的控制，仅仅从代码层面看，也很难组织清楚代码的执行顺序和逻辑。
Swift从代码层面提供了结构化的方式来支持异步编程，在Swift5.5中引入了async和await相关的关键字。需要注意，异步和并行本身是两个概念，在Swift中，异步编程模型已经建立在线程调度之上，这也就是说，我们无需关心其中线程的调用，异步的函数本身就是在子线程中并行执行的，线程切换和调度全有语言本身控制。但是Swift不会保证函数会在哪个特定的线程上执行。
异步函数
在尝试Swift中提供的异步编程方式外，可以先回想下对于异步并行的场景，之前是如何处理的，例如下面的代码：
func test(callback: @escaping (_ success: Bool)->Void) {
DispatchQueue.global().async {
print("Test任务完成", Thread.current)
callback(true)
}
}
print("Begin", Thread.current)
test { success in
print("EndTest")
}
print("End", Thread.current)其中test函数所执行的任务是手动放在全局队列中执行的，DispatchQueue会自动的进行线程的调度，将其分配到空闲的子线程来执行。打印结果如下：
Begin <_NSMainThread: 0x600002310100>{number = 1, name = main}
End <_NSMainThread: 0x600002310100>{number = 1, name = main}
Test任务完成 <NSThread: 0x600002300300>{number = 5, name = (null)}
EndTest上面的示例代码比较简单，如果有更多的异步任务是依赖test任务的，则闭包回调的写法就会变得非常丑陋，代码难以阅读和维护。
在Swift5.5之后，我们可以使用async关键字来定义异步函数，编程模型会自动分配线程执行，例如：
func test1() async -> Bool {
print("ts1", Thread.current)
return true
}
func test2() async -> Bool {
print("ts2", Thread.current)
return true
}
print("Begin", Thread.current)
async let a = test1()
async let b = test2()
print("End", Thread.current)上面代码中，async关键字将函数标记为异步的，异步函数是一种特殊的函数，其支持在执行过程中被暂时的挂起，即暂停。对于普通的函数来说，会有3种状态：
1. 执行完成
2. 抛出异常
3. 永不返回
异步函数对应的也会有这3种状态，不同的是，当需要做某些等待操作时，其可以暂时的挂起。运行上面的代码，打印效果如下：
Begin <_NSMainThread: 0x60000329c3c0>{number = 1, name = main}
End <_NSMainThread: 0x60000329c3c0>{number = 1, name = main}
ts1 <NSThread: 0x60000328cc40>{number = 4, name = (null)}
ts2 <NSThread: 0x600003282d40>{number = 6, name = (null)}可以看到，test1和test2两个任务是异步执行，且被分配在了不同的线程。需要注意，理论上在异步函数中是不允许使用Thread相关接口的，因为任务的挂起和恢复所在线程都是由系统调度的，逻辑上开发者无需关心线程问题，在Swift6版本中继续这样使用将会报错。
上面演示的代码中，test1和test2任务的执行并不依赖关系，如果test2和执行是需要test1执行结束的，则可以直接使用await关键字来将运行挂起，直到结果返回。例如：
func test1() async -> Bool {
print("ts1", Thread.current)
return true
}
func test2() async -> Bool {
print("ts2", Thread.current)
return true
}
print("Begin", Thread.current)
let a = await test1()
let b = await test2()
print("End", Thread.current)打印效果如下：
Begin <_NSMainThread: 0x600002180140>{number = 1, name = main}
ts1 <NSThread: 0x600002198100>{number = 6, name = (null)}
ts2 <NSThread: 0x6000021accc0>{number = 8, name = (null)}
End <_NSMainThread: 0x600002180140>{number = 1, name = main}使用await关键字标记的地方为程序的挂起点，此时会停止当前线程上代码的执行，并等待异步函数的返回，在程序中，支持await进行挂起的场景包括：
1.异步的方法，属性或函数中。
2.main代码块中。
3.非结构化的子任务代码块中。
通常，我们直接使用await调用异步函数时，当前执行会被挂起，更多时候可以使用如下方式来同时执行多个异步函数，使用await来最终获得结果：
func test1() async -> Bool {
print("ts1", Thread.current)
return true
}
func test2() async -> Bool {
print("ts2", Thread.current)
return true
}
print("Begin", Thread.current)
async let a = test1()
async let b = test2()
let res = await [a ,b]
print(res)
print("End", Thread.current)异步序列
Swift中的迭代也支持异步返回，通过AsyncIteratorProtocol协议来定义异步的迭代器，示例如下：
struct Group: AsyncSequence {
typealias Element = Int
let limit: Int
struct AsyncIterator : AsyncIteratorProtocol {
let limit: Int
var current = 1
mutating func next() async -> Int? {
guard !Task.isCancelled else {
return nil
}
guard current <= limit else {
return nil
}
let result = current
current += 1
return result
}
}
func makeAsyncIterator() -> AsyncIterator {
return AsyncIterator(limit: limit)
}
}
print("Begin")
let group = Group(limit: 10)
for await i in group {
print(i)
}
print("End")在对异步迭代器进行遍历时，需要使用for await in的语法方式。
任务组与任务
当有多个异步任务需要执行时，可以将其添加到一个任务组中，当任务组所有任务完成后再进行统一的返回。例如：
let res = await withTaskGroup(of: Bool.self, returning: [Bool].self, body: { taskGroup in
taskGroup.addTask {
let a = await test1()
return a
}
taskGroup.addTask {
let b = await test1()
return b
}
var datas:[Bool] = []
for await data in taskGroup {
datas.append(data)
}
return datas
})
print(res)其中，withTaskGroup方法将创建一个异步的父任务，其中可以添加多个子任务，任务组之间有非常明确的关系，这种编程方式也被称为结构化编程，当然，Swift也提供了非结构化的编程方式，即需要开发者处理任务之间的关系。这非常有用，有时我们需要在非并发的环境中调用异步函数，例如在iOS Application中ViewController的viewDidLoad方法中调用一个异步的函数，此时就需要为其包装一个并发环境，使用Task来创建任务即可：
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
Task(priority: .background) {
await test()
self.view.backgroundColor = .red
print("Finish")
}
// 上面task的执行不会影响当前线程
print("Continue")
}
func test() async {
try? await Task.sleep(for: .seconds(10))
}
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
print("touch")
print(Thread.current)
}
}这里再强调一下，所谓执行任务的挂起和线程的阻塞完全不同，当并发环境中当前任务被挂起时，线程资源会被释放去执行其他任务，直到异步任务有结果后，在恢复执行。上面代码中并没有记录Task实例，其实此实例可以控制任务的取消，获取任务返回值等操作，例如：
override func viewDidLoad() {
super.viewDidLoad()
let task = Task(priority: .background) {
await test()
self.view.backgroundColor = .red
print("Finish")
return "result"
}
// 上面task的执行不会影响当前线程
print("Continue")
// 取消任务
task.cancel()
}