一、异步编程初相识
在计算机编程的世界里，我们常常会遇到一些任务，比如从网络上下载文件、访问数据库或者进行复杂的计算。这些任务往往会花费比较长的时间，如果我们采用同步编程的方式，程序就会一直等待这些任务完成，在等待的过程中，程序无法去做其他的事情，这就好像我们在排队等待买咖啡，在排队的过程中什么都不能做，只能眼巴巴地等着。而异步编程就像是我们在排队的时候可以顺便看看手机、和朋友聊聊天，让程序在等待一个任务完成的同时去处理其他的事情，从而提高程序的运行效率。
在 Swift 语言中，异步编程的发展经历了几个阶段，从最初的回调函数，到后来的闭包，再到现在的 async/await 语法，每一次的演进都让异步编程变得更加简洁、安全和易于理解。
二、回调函数时代
2.1 回调函数的基本概念
回调函数是异步编程最早使用的一种方式。简单来说，回调函数就是我们把一个函数作为参数传递给另一个函数，当那个函数执行完某项任务后，就会调用我们传递进去的这个函数。
下面是一个简单的 Swift 示例，模拟一个网络请求：
// 定义一个网络请求的函数，接收一个回调函数作为参数
func makeNetworkRequest(completion: @escaping (String?, Error?) -> Void) {
// 模拟网络请求的延迟
DispatchQueue.global().asyncAfter(deadline: .now() + 2) {
let success = Bool.random()
if success {
// 模拟请求成功，返回数据
completion("这是从服务器返回的数据", nil)
} else {
// 模拟请求失败，返回错误
completion(nil, NSError(domain: "NetworkError", code: 1001, userInfo: [NSLocalizedDescriptionKey: "网络请求失败"]))
}
}
}
// 调用网络请求函数，并传入回调函数
makeNetworkRequest { (data, error) in
if let data = data {
print("请求成功，数据为: \(data)")
} else if let error = error {
print("请求失败，错误信息: \(error.localizedDescription)")
}
}
在这个示例中，makeNetworkRequest 函数模拟了一个网络请求，接收一个回调函数作为参数。当请求完成后，根据请求结果调用回调函数，并传递相应的数据或错误信息。调用 makeNetworkRequest 函数时，我们传入了一个闭包作为回调函数，在闭包中处理请求的结果。
2.2 回调函数的缺点
回调函数虽然能够实现异步编程，但是也存在一些明显的缺点。首先是回调地狱的问题。当我们需要进行多个异步操作，并且这些操作之间有依赖关系时，就会出现回调函数嵌套回调函数的情况，代码会变得非常复杂，难以阅读和维护。
以下是一个简单的示例，模拟多个具有依赖关系的网络请求：
func firstRequest(completion: @escaping (String?, Error?) -> Void) {
DispatchQueue.global().asyncAfter(deadline: .now() + 1) {
completion("第一个请求的数据", nil)
}
}
func secondRequest(withData data: String, completion: @escaping (String?, Error?) -> Void) {
DispatchQueue.global().asyncAfter(deadline: .now() + 1) {
completion("基于 \(data) 处理后的第二个请求的数据", nil)
}
}
func thirdRequest(withData data: String, completion: @escaping (String?, Error?) -> Void) {
DispatchQueue.global().asyncAfter(deadline: .now() + 1) {
completion("基于 \(data) 处理后的第三个请求的数据", nil)
}
}
firstRequest { (firstData, firstError) in
if let firstData = firstData {
secondRequest(withData: firstData) { (secondData, secondError) in
if let secondData = secondData {
thirdRequest(withData: secondData) { (thirdData, thirdError) in
if let thirdData = thirdData {
print("最终结果: \(thirdData)")
} else if let thirdError = thirdError {
print("第三个请求失败，错误信息: \(thirdError.localizedDescription)")
}
}
} else if let secondError = secondError {
print("第二个请求失败，错误信息: \(secondError.localizedDescription)")
}
}
} else if let firstError = firstError {
print("第一个请求失败，错误信息: \(firstError.localizedDescription)")
}
}
从这个示例中可以看到，随着请求数量的增加，回调函数的嵌套层数也在不断增加，代码变得越来越难以理解和调试。
三、闭包的优化
闭包在一定程度上可以看作是回调函数的一种更灵活的表达方式。在 Swift 中，闭包可以捕获其周围环境中的变量和常量，并在其内部使用。虽然闭包并没有从根本上解决回调地狱的问题，但是它让代码的书写更加简洁。
以下是使用闭包优化后的前面的多个网络请求示例：
// 封装网络请求函数
func performRequest(name: String, delay: TimeInterval, data: String? = nil, completion: @escaping (String?, Error?) -> Void) {
DispatchQueue.global().asyncAfter(deadline: .now() + delay) {
let result = data != nil ? "基于 \(data!) 处理后的 \(name) 请求的数据" : "\(name) 请求的数据"
completion(result, nil)
}
}
// 使用闭包链式调用
performRequest(name: "第一个", delay: 1) { (firstData, firstError) in
guard let firstData = firstData, firstError == nil else { return }
performRequest(name: "第二个", delay: 1, data: firstData) { (secondData, secondError) in
guard let secondData = secondData, secondError == nil else { return }
performRequest(name: "第三个", delay: 1, data: secondData) { (thirdData, thirdError) in
if let thirdData = thirdData {
print("最终结果: \(thirdData)")
}
}
}
}
通过使用闭包，我们封装了网络请求函数，让代码的复用性得到了提高，但是回调地狱的问题还是存在。
四、async/await 横空出世
4.1 async/await 的基本概念
Swift 5.5 引入了 async/await 语法，这是一种全新的异步编程方式，它让异步代码的书写看起来就像同步代码一样简单。async 关键字用于标记一个函数是异步函数，await 关键字用于等待一个异步函数的返回结果。
以下是使用 async/await 重写前面的多个网络请求示例：
// 定义异步函数
func performAsyncRequest(name: String, delay: TimeInterval, data: String? = nil) async throws -> String {
try await Task.sleep(nanoseconds: UInt64(delay * 1_000_000_000))
let result = data != nil ? "基于 \(data!) 处理后的 \(name) 请求的数据" : "\(name) 请求的数据"
return result
}
// 调用异步函数
Task {
do {
let firstData = try await performAsyncRequest(name: "第一个", delay: 1)
let secondData = try await performAsyncRequest(name: "第二个", delay: 1, data: firstData)
let thirdData = try await performAsyncRequest(name: "第三个", delay: 1, data: secondData)
print("最终结果: \(thirdData)")
} catch {
print("请求失败，错误信息: \(error.localizedDescription)")
}
}
在这个示例中，performAsyncRequest 函数被标记为异步函数，使用 await 关键字等待函数的返回结果。通过 Task 来启动一个异步任务，在任务中调用异步函数，代码的结构变得非常清晰，就像同步代码一样。
4.2 async/await 的优势
- 代码简洁易读：async/await 让异步代码的书写更加简洁，避免了回调地狱的问题，代码的逻辑更加清晰，易于阅读和维护。
- 错误处理方便：使用 try/catch 语句可以方便地处理异步函数中抛出的错误，而不需要在回调函数中进行复杂的错误处理。
4.3 async/await 的注意事项
- 只能在异步上下文中使用：
await关键字只能在异步函数或者异步上下文中使用，不能在普通的同步函数中使用。 - 性能开销：虽然 async/await 让代码更加简洁，但是它也会带来一定的性能开销，尤其是在处理大量并发任务时，需要注意性能优化。
五、应用场景
5.1 网络请求
在开发 iOS 应用时，网络请求是非常常见的异步操作。使用 async/await 可以让网络请求的代码更加简洁和易于维护。
import Foundation
// 定义一个异步函数来执行网络请求
func fetchData(from url: URL) async throws -> Data {
let (data, _) = try await URLSession.shared.data(from: url)
return data
}
// 使用示例
Task {
let url = URL(string: "https://www.example.com")!
do {
let data = try await fetchData(from: url)
// 处理返回的数据
if let json = try? JSONSerialization.jsonObject(with: data, options: []) {
print(json)
}
} catch {
print("请求失败，错误信息: \(error.localizedDescription)")
}
}
5.2 文件读写
文件读写操作也可能会花费比较长的时间，使用异步编程可以避免阻塞主线程。
import Foundation
// 异步写入文件
func writeToFile(content: String, at url: URL) async throws {
try await withCheckedThrowingContinuation { continuation in
do {
try content.write(to: url, atomically: true, encoding: .utf8)
continuation.resume()
} catch {
continuation.resume(throwing: error)
}
}
}
// 异步读取文件
func readFromFile(at url: URL) async throws -> String {
return try await withCheckedThrowingContinuation { continuation in
do {
let content = try String(contentsOf: url, encoding: .utf8)
continuation.resume(with: .success(content))
} catch {
continuation.resume(with: .failure(error))
}
}
}
// 使用示例
Task {
let fileURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!.appendingPathComponent("test.txt")
let content = "这是要写入文件的内容"
do {
try await writeToFile(content: content, at: fileURL)
let readContent = try await readFromFile(at: fileURL)
print("读取的内容: \(readContent)")
} catch {
print("文件操作失败，错误信息: \(error.localizedDescription)")
}
}
六、文章总结
Swift 异步编程从最初的回调函数到现在的 async/await，经历了不断的发展和演进。回调函数是最早的异步编程方式，虽然能够实现异步操作，但是存在回调地狱的问题，代码的可维护性较差。闭包在一定程度上优化了回调函数的书写，提高了代码的复用性，但并没有从根本上解决问题。而 async/await 语法的引入，让异步代码的书写变得更加简洁、安全和易于理解，就像同步代码一样，大大提高了开发效率。
在实际开发中，我们应该根据具体的需求和场景选择合适的异步编程方式。对于简单的异步操作，回调函数和闭包仍然可以使用；而对于复杂的异步操作，尤其是涉及多个异步任务之间有依赖关系的情况，async/await 无疑是更好的选择。
评论