Swift对比Kotlin协程

Swift 的异步编程模型（Swift Concurrency）和 Kotlin 协程在目标上类似，都旨在简化异步代码的编写，但在实现和语法上有一些不同。以下是 Swift 中类似 Kotlin 协程的操作和特性：

1. `async`/`await` 语法

Swift 5.5 引入了 async/await 语法，允许开发者以同步的方式编写异步代码，类似 Kotlin 协程的挂起函数：


// Swift 示例
func fetchData() async throws -> Data {
    let url = URL(string: "https://example.com")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return data
}

// 调用异步函数
Task {
    do {
        let data = try await fetchData()
        print("Data received: \(data)")
    } catch {
        print("Error: \(error)")
    }
}

Kotlin 协程的等效代码：


// Kotlin 示例
suspend fun fetchData(): Data {
    return withContext(Dispatchers.IO) {
        URL("https://example.com").readBytes()
    }
}

// 启动协程
viewModelScope.launch {
    try {
        val data = fetchData()
        println("Data received: $data")
    } catch (e: Exception) {
        println("Error: $e")
    }
}

2. 结构化并发（Structured Concurrency）

Swift 通过 Task 和 TaskGroup 实现结构化并发，确保子任务的生命周期与父任务绑定（类似 Kotlin 协程的作用域）：


// Swift 示例
func processMultipleRequests() async {
    await withTaskGroup(of: Data.self) { group in
        for url in urls {
            group.addTask {
                let (data, _) = try await URLSession.shared.data(from: url)
                return data
            }
        }
        
        // 收集结果
        for await result in group {
            print("Received data: \(result)")
        }
    }
}

类似 Kotlin 的 coroutineScope：


// Kotlin 示例
suspend fun processMultipleRequests() = coroutineScope {
    val deferredList = urls.map { url ->
        async(Dispatchers.IO) {
            URL(url).readBytes()
        }
    }
    deferredList.awaitAll().forEach { data ->
        println("Received data: $data")
    }
}

3. 调度器与线程切换

Kotlin 协程通过 Dispatchers（如 Dispatchers.IO、Dispatchers.Main）切换线程，而 Swift 通过 Task 的调度器参数或 MainActor 实现主线程切换：


// Swift 示例
Task { 
    // 默认在后台线程执行
    let data = await fetchData()
    
    // 切回主线程更新 UI
    await MainActor.run {
        self.label.text = "Data loaded"
    }
}

4. 取消与协作式任务

Swift 的 Task 支持取消操作，通过检查 Task.isCancelled 或调用 Task.cancel()：


let task = Task {
    guard !Task.isCancelled else { return }
    // 执行耗时操作
}

// 取消任务
task.cancel()

类似 Kotlin 协程的 Job.cancel()。

5. `AsyncSequence` 与 Flow

Swift 的 AsyncSequence 允许按需异步生成值（类似 Kotlin 的 Flow）：


// Swift 示例
func countNumbers() async {
    let stream = AsyncStream(Int.self) { continuation in
        Task {
            for i in 1...10 {
                continuation.yield(i)
                try await Task.sleep(nanoseconds: 1_000_000_000)
            }
            continuation.finish()
        }
    }
    
    for await number in stream {
        print(number)
    }
}

主要区别

特性	Swift Concurrency	Kotlin 协程
语法	`async`/`await` + `Task`	`suspend` + `launch`/`async`
调度器	`MainActor`、全局 Actor	`Dispatchers.Main`、`Dispatchers.IO`
底层机制	编译器生成状态机 + Continuation	状态机 + 挂起函数
结构化并发	`TaskGroup`、`async let`	`coroutineScope`、`supervisorScope`

总结

Swift Concurrency（async/await + Task + Actor）提供了与 Kotlin 协程类似的能力，核心目标都是简化异步代码。
如果需要更细粒度的控制（如自定义线程池），可以结合 DispatchQueue 使用，但官方推荐优先使用 Swift 的原生并发模型。
学习资源：Swift 并发官方文档。

1. async/await 语法