Swift异步详解Swift 的异步编程模型是现代 Swift 开发的核心特性之一，尤其在 Swift 5.5 引入 a

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

六、最佳实践

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

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

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

限制并发量：用 TaskGroup 配合信号量控制并发数量
优先使用 async/await：相比回调和 Combine，代码更简洁易读

总结

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

Swift异步详解