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