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

新增加的办法运用了 Swift 中引进的 withCheckedThrowingContinuation 办法，能够不费吹灰之力地转化依据闭包的办法。不抛出的办法能够运用 withCheckedContinuation，其作业原理与此相同，但不支撑抛出过错。

这两个办法会暂停当前使命，直到给定的闭包被调用以触发 async-await 办法的持续。换句话说：你必须保证依据你自己的依据闭包的办法的回调来调用 continuation 闭包。在咱们的比如中，这归结为用咱们从开始的 fetchImages 回调回来的成果值来调用持续。

为你的项目挑选正确的 async-await 重构办法

这三个重构选项应该足以将你现有的代码转化为异步的代替品。依据你的项目规划和你的重构时间，你或许想挑选一个不同的重构选项。不过，我强烈建议逐渐运用改动，由于它答应你阻隔改动的部分，使你更简单测验你的改动是否如预期那样作业。

处理过错

处理 “Reference to captured parameter ‘self’ in concurrently-executing code “过错

在运用异步办法时，另一个常见的过错是下面这个:

“Reference to captured parameter ‘self’ in concurrently-executing code”

这大致意思是说咱们正企图引证一个不可变的self实例。换句话说，你或许是在引证一个特点或一个不可变的实例，例如，像下面这个比如中的结构体：

不支撑从异步履行的代码中修正不可变的特点或实例。

能够经过使特点可变或将结构体更改为引证类型（如类）来修正此过错。

枚举的终点

async-await 将是Result枚举的终点吗？

咱们已经看到，异步办法替代了运用闭包回调的异步办法。咱们能够问自己，这是否会是 Swift 中 Result 枚举的终点。终究咱们会发现，咱们真的不再需求它们了，由于咱们能够运用 try-catch 句子与 async-await 相结合。

Result 枚举不会很快消失，由于它仍然在整个 Swift 项目的许多地方被运用。但是，一旦 async-await 的选用率越来越高，我就不会惊奇地看到它被抛弃。就我个人而言，除了完结回调，我没有在其他地方运用成果枚举。一旦我完全运用 async-await，我就不会再运用这个枚举了。

结论

Swift 中的 async-await 答应结构化并发，这将提高复杂异步代码的可读性。不再需求完结闭包，而在彼此之后调用多个异步办法的可读性也大大增强。一些新的过错类型或许会产生，经过保证异步办法是从支撑并发的函数中调用的，一起不改动任何不可变的引证，这些过错将能够得到处理。

本文正在参加「金石计划 . 分割6万现金大奖」

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

前言

什么是 async?

async 如何替代完结回调闭包

什么是 await？

什么是结构化并发？

调用异步办法

选用 async-await

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

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

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

为你的项目挑选正确的 async-await 重构办法

处理过错

枚举的终点

结论

作者信息

推广

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

前言

什么是 async?

async 如何替代完结回调闭包

什么是 await？

什么是结构化并发？

调用异步办法

选用 async-await

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

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

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

为你的项目挑选正确的 async-await 重构办法

处理过错

枚举的终点

结论

相关文章

Gradle理论与实践二：Groovy介绍

走出第一步，我是如何写一篇技术文章的

实现缓存和数据库一致性方案实战：mysql+canal+rabbitmq+redis

【CVPR2023】Backbone FasterNet：我不允许你不知道世界上还有比ShuffleNetV2还轻量的网络！

作者信息

推广