Swift 中的 async/await ——代码实例详解

前言

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

你可能读过 Chris Lattner 的 Swift 并发性宣言 Swift Concurrency Manifesto by Chris Lattner，这是在几年前发布的。Swift社区的许多开发者对未来将出现的定义异步代码的结构化方式感到兴奋。现在它终于来了，我们可以用 async-await 简化我们的代码，使我们的异步代码更容易阅读。

什么是 async?

async 是异步的意思，可以看作是一个明确表示一个方法是执行异步工作的一个属性。这样一个方法的例子看起来如下：

func fetchImages() async throws -> [UIImage] {
    // ..  执行数据请求
}

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

async 如何取代完成回调闭包

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

func fetchImages(completion: (Result<[UIImage], Error>) -> Void) {
    // .. 执行数据请求
}

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

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

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

func fetchImages(completion: ([UIImage]?, Error?) -> Void) {
    // .. 执行数据请求
}

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

什么是 await？

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

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

尽管这听起来很幼稚，但这并不是骗人的! 我们可以通过调用我们先前定义的异步方法 fetchImages 方法来看一个例子：

do {
    let images = try await fetchImages()
    print("Fetched \(images.count) images.")
} catch {
    print("Fetching images failed with error \(error)")
}

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

什么是结构化并发？

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

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

// 1. 调用这个方法
fetchImages { result in
    // 3. 异步方法内容返回
    switch result {
    case .success(let images):
        print("Fetched \(images.count) images.")
    case .failure(let error):
        print("Fetching images failed with error \(error)")
    }
}
// 2. 调用方法结束

正如你所看到的，调用方法在获取图像之前结束。最终，我们收到了一个结果，然后我们回到了完成回调的流程中。这是一个非结构化的执行顺序，可能很难遵循。如果我们在完成回调中执行另一个异步方法，毫无疑问这会增加另一个闭包回调：

// 1. 调用这个方法
fetchImages { result in
    // 3. 异步方法内容返回
    switch result {
    case .success(let images):
        print("Fetched \(images.count) images.")
        
        // 4. 调用 resize 方法
        resizeImages(images) { result in
            // 6. Resize 方法返回
            switch result {
            case .success(let images):
                print("Decoded \(images.count) images.")
            case .failure(let error):
                print("Decoding images failed with error \(error)")
            }
        }
        // 5. 获图片方法返回
    case .failure(let error):
        print("Fetching images failed with error \(error)")
    }
}
// 2. 调用方法结束

每一个闭包都会增加一层缩进，这使得我们更难理解执行的顺序。

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

do {
    // 1. 调用这个方法
    let images = try await fetchImages()
    // 2.获图片方法返回
    
    // 3. 调用 resize 方法
    let resizedImages = try await resizeImages(images)
    // 4.Resize 方法返回
    
    print("Fetched \(images.count) images.")
} catch {
    print("Fetching images failed with error \(error)")
}
// 5. 调用方法结束

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

调用异步方法

在一个不支持并发的函数中调用异步方法

在第一次使用 async-await 时，你可能会遇到这样的错误。

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

func fetchData() async {
    do {
        try await fetchImages()
    } catch {
        // .. handle error
    }
}

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

final class ContentViewModel: ObservableObject {
    
    @Published var images: [UIImage] = []
    
    func fetchData() {
        Task.init {
            do {
                self.images = try await fetchImages()
            } catch {
                // .. handle error
            }
        }
    }
}

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

采用 async-await

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

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

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

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

struct ImageFetcher {
    func fetchImages(completion: @escaping (Result<[UIImage], Error>) -> Void) {
        // .. 执行数据请求
    }
}

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

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

struct ImageFetcher {
    func fetchImages() async throws -> [UIImage] {
        // .. 执行数据请求
    }
}

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

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

struct ImageFetcher {
    @available(*, renamed: "fetchImages()")
    func fetchImages(completion: @escaping (Result<[UIImage], Error>) -> Void) {
        Task {
            do {
                let result = try await fetchImages()
                completion(.success(result))
            } catch {
                completion(.failure(error))
            }
        }
    }


    func fetchImages() async throws -> [UIImage] {
        // .. 执行数据请求
    }
}

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

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

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

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

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

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

struct ImageFetcher {
    @available(*, renamed: "fetchImages()")
    func fetchImages(completion: @escaping (Result<[UIImage], Error>) -> Void) {
        // .. 执行数据请求
    }

    func fetchImages() async throws -> [UIImage] {
        return try await withCheckedThrowingContinuation { continuation in
            fetchImages() { result in
                continuation.resume(with: result)
            }
        }
    }
}