Swift 中的 async/await

一、简介

async-await 是在 WWDC 2021 期间的 Swift 5.5 中的结构化并发变化的一部分。Swift 中的并发性意味着允许多段代码同时运行。这是一个非常简化的描述，但它应该让你知道 Swift 中的并发性对你的应用程序的性能是多么重要。有了新的 async 方法和 await 语句，我们可以定义方法来进行异步工作。

二、 async

async 是异步的意思，可以看作是一个明确表示一个方法是执行异步工作的一个属性。这样一个方法的例子看起来如下：
**注意：**async 需要在iOS13版本以上使用

func request() async throws {
        // 执行数据请求
    }

request 方法被定义为异步且可以抛出异常，这意味着它正在执行一个可失败的异步作业。如果一切顺利，该方法将返回请求结果，如果出现问题，则抛出错误。

async 如何取代完成回调闭包

async 方法取代了经常看到的完成回调。完成回调在 Swift 中很常见，用于从异步任务中返回，通常与一个结果类型的参数相结合。上述方法一般会被写成这样:

func request(completion: @escaping (Any?, Error) -> Void) {
    // .. 执行数据请求
}

在如今的 Swift 版本中，使用完成闭包来定义方法仍然是可行的，但它有一些缺点，async 却刚好可以解决。

• 你必须确保自己在每个可能的退出方法中调用完成闭包。如果不这样做，可能会导致应用程序无休止地等待一个结果。
• 闭包代码比较难阅读。与结构化并发相比，对执行顺序的推理并不那么容易。
• 需要使用弱引用 weak references 来避免循环引用。
• 实现者需要对结果进行切换以获得结果。无法从实现层面使用 try catch 语句。

这些缺点是基于使用相对较新的 Result 枚举的闭包版本。很可能很多项目仍然在使用完成回调，而没有使用这个枚举：

func request(completion: @escaping (Any?, Error?) -> Void) {
        // 执行数据请求
    }

像这样定义一个方法使我们很难推理出调用者一方的结果。value 和 error 都是可选的，这要求我们在任何情况下都要进行解包。对这些可选项解包会导致更多的代码混乱，这对提高可读性没有帮助。

三、await

await 是用于调用异步方法的关键字。你可以把它们 (async-await) 看作是 一体的，因为一个永远不会离开另一个，你基本上可以这样说：

“Await 正在等待来自他的伙伴 async 的回调”
调用示例：

		do {
            let result = try await request()
            print("Fetched \(result)")
        } catch {
            print("Fetching failed with error \(error)")
        }

也许你很难相信，但上面的代码例子是在执行一个异步任务。使用 await 关键字，我们告诉我们的程序等待 request 方法的结果，只有在结果到达后才继续。这可能是一个请求结果，也可能是一个在请求时出了什么问题的错误。

四、什么是结构化并发？

使用 async-await 方法调用的结构化并发使得执行顺序的推理更加容易。方法是线性执行的，不用像闭包那样来回走动。

为了更好地解释这一点，我们可以看看在结构化并发到来之前，我们如何调用上述代码示例：

// 1. 调用这个方法
        request { result,error  in
            // 3. 异步方法内容返回
            guard let result = result else {
                print("Fetching images failed with error \(error)")
                return
            }
            print("success\(result)")
        }
        // 2. 调用方法结束

正如你所看到的，调用方法在请求完成之前结束。最终，我们收到了一个结果，然后我们回到了完成回调的流程中。这是一个非结构化的执行顺序，可能很难遵循。如果我们在完成回调中执行另一个异步方法，毫无疑问这会增加另一个闭包回调，每一个闭包都会增加一层缩进，这使得我们更难理解执行的顺序。

通过使用 async-await 重写上述代码示例，最好地解释了结构化并发的作用。

 do {
	// 1. 调用这个方法
	let result = try await request()
	let result1 = try await request(result)
	print("Fetched \(result1)")
} catch {
	print("Fetching images failed with error \(error)")
}
// 3. 调用方法结束

执行的顺序是线性的，因此，容易理解，容易推理。当我们有时还在执行复杂的异步任务时，理解异步代码会更容易。

五、调用异步方法

在一个不支持并发的函数中调用异步方法
在第一次使用 async-await 时，你可能会遇到这样的错误。
'async' call in a function that does not support concurrency

当我们试图从一个不支持并发的同步调用环境中调用一个异步方法时，就会出现这个错误。我们可以通过将我们的 responst 方法也定义为异步来解决这个错误：

func responst() async {
        do {
            let result = try await request()
            print("Fetched \(result)")
        } catch {
            print("Fetching failed with error \(error)")
        }
}

然而，这将把错误转移到另一个地方。相反，我们可以使用 Task.init 方法，从一个支持并发的新任务中调用异步方法，并将结果分配给我们视图模型中的一个属性：

func responst() {
        Task.init {
            do {
                let result = try await request()
                print("Fetched \(result)")
            } catch {
                print("Fetching failed with error \(error)")
            }
        }
}

使用尾随闭包的异步方法，我们创建了一个环境，在这个环境中我们可以调用异步方法。一旦异步方法被调用，获取数据的方法就会返回，之后所有的异步回调都会在闭包内发生。

六、采用 async-await

在一个现有项目中采用 async-await

当在现有项目中采用 async-await 时，你要注意不要一下子破坏所有的代码。在进行这样的大规模重构时，最好考虑暂时维护旧的实现，这样你就不必在知道新的实现是否足够稳定之前更新所有的代码。这与 SDK 中被许多不同的开发者和项目所使用的废弃方法类似。

显然，你没有义务这样做，但它可以使你更容易在你的项目中尝试使用 async-await。除此之外，Xcode 使重构你的代码变得超级容易，还提供了一个选项来创建一个单独的 async 方法：

每个重构方法都有自己的目的，并导致不同的代码转换。为了更好地理解其工作原理，我们将使用下面的代码作为重构的输入：

func request(completion: @escaping (Any?, Error?) -> Void) {
        // 执行数据请求
    }

将函数转换为异步 (Convert Function to Async)

第一个重构选项将 request 方法转换为异步变量，而不保留非异步变量。如果你不想保留原来的实现，这个选项将很有用。结果代码如下：

func request() async throws -> Any {
        // 执行数据请求
    }

添加异步替代方案 (Add Async Alternative)

添加异步替代重构选项确保保留旧的实现，但会添加一个可用（available） 属性：

@available(*, deprecated, renamed: "request()", message: "请求方法")
    func request(completion: @escaping(Result<Any, Error>) -> Void) {
        // 执行数据请求
        Task {
            do {
                let result = try await request()
                completion(.success(result))
            } catch {
                completion(.failure(error))
            }
        }
    }
    
    func request() async throws -> Any {
        // 执行数据请求
    }

可用属性对于了解你需要在哪里更新你的代码以适应新的并发变量是非常有用的。虽然，Xcode 提供的默认实现并没有任何警告，因为它没有被标记为废弃的。要做到这一点，你需要调整可用标记，如下所示:

@available(*, deprecated, renamed: "request()")

使用这种重构选项的好处是，它允许你逐步适应新的结构化并发变化，而不必一次性转换你的整个项目。在这之间进行构建是很有价值的，这样你就可以知道你的代码变化是按预期工作的。利用旧方法的实现将得到如下的警告。

你可以在整个项目中逐步改变你的实现，并使用Xcode中提供的修复按钮来自动转换你的代码以利用新的实现。

添加异步包装器 (Add Async Wrapper)

最后的重构方法将使用最简单的转换，因为它将简单地利用你现有的代码：

@available(*, deprecated, renamed: "request()", message: "请求方法")
    func request(completion: @escaping(Result<Any, Error>) -> Void) {
        // 执行数据请求
    }
    
    func request() async throws -> Any {
        // 执行数据请求
        return try await withCheckedThrowingContinuation { continuation in
            request { result in
                continuation.resume(with: result)
            }
        }
    }

新增加的方法利用了 Swift 中引入的 withCheckedThrowingContinuation 方法，可以不费吹灰之力地转换基于闭包的方法。不抛出的方法可以使用 withCheckedContinuation，其工作原理与此相同，但不支持抛出错误。

这两个方法会暂停当前任务，直到给定的闭包被调用以触发 async-await 方法的继续。换句话说：你必须确保根据你自己的基于闭包的方法的回调来调用 continuation 闭包。在我们的例子中，这归结为用我们从最初的 fetchImages 回调返回的结果值来调用继续。

注意：withCheckedThrowingContinuation和Task均为iOS13以后的方法。

总结

Swift 中的 async-await 允许结构化并发，这将提高复杂异步代码的可读性。不再需要完成闭包，而在彼此之后调用多个异步方法的可读性也大大增强。一些新的错误类型可能会发生，通过确保异步方法是从支持并发的函数中调用的，同时不改变任何不可变的引用，这些错误将可以得到解决。