Swift异步详解

Swift 的异步编程模型是现代 Swift 开发的核心特性之一，尤其在 Swift 5.5 引入 async/await 语法后，极大简化了异步操作的处理。以下是对 Swift 异步编程的详细解析：

一、异步编程的核心问题

在传统同步代码中，操作按顺序执行，耗时操作（如网络请求、文件读写）会阻塞当前线程。而异步编程的目的是：

• 避免耗时操作阻塞 UI 或主线程
• 提高代码可读性和可维护性
• 简化复杂异步逻辑（如依赖多个异步任务的场景）

二、Swift 异步的三种主要方式

1. 回调闭包（Closure Callback）

最传统的方式，通过闭包传递异步结果：

func fetchData(completion: @escaping (Result<String, Error>) -> Void) {
    DispatchQueue.global().asyncAfter(deadline: .now() + 1) {
        // 模拟网络请求
        completion(.success("Data from server"))
    }
}

// 调用
fetchData { result in
    switch result {
    case .success(let data):
        print(data)
    case .failure(let error):
        print(error)
    }
}

缺点：多层嵌套易形成"回调地狱"，逻辑复杂时可读性差。

2. Combine 框架（响应式编程）

基于发布者（Publisher）和订阅者（Subscriber）模式，适合处理数据流：

import Combine

func fetchData() -> AnyPublisher<String, Error> {
    return Future<String, Error> { promise in
        DispatchQueue.global().asyncAfter(deadline: .now() + 1) {
            promise(.success("Data from server"))
        }
    }
    .eraseToAnyPublisher()
}

// 调用
let cancellable = fetchData()
    .receive(on: DispatchQueue.main)
    .sink(receiveCompletion: { completion in
        // 处理完成或错误
    }, receiveValue: { data in
        print(data)
    })

优势 ：强大的操作符（如 map、flatMap）支持复杂数据流处理，适合响应式场景。

3. async/await 语法（Swift 5.5+）

现代异步编程的主流方式，用同步代码的形式编写异步逻辑：

// 定义异步函数
func fetchData() async throws -> String {
    try await Task.sleep(nanoseconds: 1_000_000_000) // 模拟耗时1秒
    return "Data from server"
}

// 调用异步函数（需在异步上下文中）
Task {
    do {
        let data = try await fetchData()
        print(data)
    } catch {
        print(error)
    }
}

核心特点：

• 用 async 标记函数为异步
• 用 await 等待异步结果（不会阻塞线程）
• 用 try 处理可能的错误
• 必须在异步上下文（如 Task）中调用

三、async/await 深度解析

1. 异步函数的定义与调用

• 函数声明：用 async 关键字标记，可返回值或抛出错误

  func loadUser() async throws -> User
  func cacheData() async // 无返回值

• 调用限制：必须在 async 函数内或 Task 中使用 await 调用

  // 正确：在Task中调用
  Task {
      let user = try await loadUser()
  }
  
  // 正确：在async函数中调用
  func process() async throws {
      let user = try await loadUser()
  }

2. 任务（Task）与并发

Task 是异步操作的载体，负责管理异步任务的生命周期：

• 创建任务 ：

  let task = Task {
      try await fetchData()
  }

• 取消任务 ：

  task.cancel() // 触发任务内部的CancellationError

• 任务优先级 ：

  Task(priority: .high) { ... } // 高优先级任务

3. 并发执行多个任务

• 并行执行 ：用 async let 同时启动多个任务，最后统一等待结果

  async let data1 = fetchData(url: url1)
  async let data2 = fetchData(url: url2)
  
  let result = try await (data1, data2) // 等待所有任务完成

• 结构化并发 ：通过 TaskGroup 管理一组动态任务

  await withTaskGroup(of: String.self) { group in
      for url in urls {
          group.addTask {
              try await fetchData(url: url)
          }
      }
      // 收集结果
      for try await data in group {
          print(data)
      }
  }

4. 主队列调度

UI 操作必须在主线程执行，可通过 @MainActor 约束：

// 标记函数必须在主线程执行
@MainActor
func updateUI(text: String) {
    label.text = text
}

// 调用时自动切换到主线程
Task {
    let data = try await fetchData()
    await updateUI(text: data) // 自动切换到主线程
}

四、异常处理

异步函数的错误通过 throws 抛出，在调用时用 try 捕获：

func riskyOperation() async throws {
    if failureCondition {
        throw MyError.somethingWrong
    }
}

// 调用时处理错误
Task {
    do {
        try await riskyOperation()
    } catch MyError.somethingWrong {
        print("特定错误处理")
    } catch {
        print("通用错误处理: \(error)")
    }
}

五、与其他异步模型的互操作

1. 回调转 async/await

用 withCheckedThrowingContinuation 将传统回调转换为异步函数：

func fetchData() async throws -> String {
    try await withCheckedThrowingContinuation { continuation in
        // 传统回调函数
        legacyFetch { result in
            switch result {
            case .success(let data):
                continuation.resume(returning: data)
            case .failure(let error):
                continuation.resume(throwing: error)
            }
        }
    }
}

2. async/await 转 Combine

用 Future 包装异步函数：

func fetchDataPublisher() -> AnyPublisher<String, Error> {
    Future { promise in
        Task {
            do {
                let data = try await fetchData()
                promise(.success(data))
            } catch {
                promise(.failure(error))
            }
        }
    }
    .eraseToAnyPublisher()
}

六、最佳实践

1. 避免阻塞 ：await 不会阻塞线程，无需手动切换到后台队列

2. 任务取消 ：在长时间任务中检查取消状态

   func longRunningTask() async throws {
       for i in 0..<100 {
           if Task.isCancelled {
               throw CancellationError()
           }
           // 执行部分任务
           try await Task.sleep(nanoseconds: 100_000_000)
       }
   }

3. 限制并发量 ：用 TaskGroup 配合信号量控制并发数量

4. 优先使用 async/await：相比回调和 Combine，代码更简洁易读

总结

Swift 的异步编程模型从回调到 Combine，再到 async/await，逐步向更简洁、更安全的方向发展。async/await 结合结构化并发，成为处理异步逻辑的首选方式，尤其适合网络请求、文件操作等场景，同时保持了与传统异步模型的兼容性。