07.6.2 Combine 与 async/await 并发
所属:全栈开发面试题库 / 07 端侧与桌面开发 / 07.6 iOS 深入
覆盖范围
- Combine 核心:Publisher、Subscriber、Operator、Cancellable
- @Published 与 Combine 的关系
- async/await 基本用法、Task 结构
- async/await 与 Combine 的互操作
- 并发安全:actor、Sendable、数据竞争
高频题速览
| 编号 | 题目 | 难度 | 频率 |
|---|---|---|---|
| 07.6.2-001 | Combine 的核心概念是什么? | 基础 | ★★★★★ |
| 07.6.2-002 | @Published 是怎么工作的? | 基础 | ★★★★ |
| 07.6.2-003 | async/await 解决了什么问题? | 基础 | ★★★★★ |
| 07.6.2-004 | Task 是什么?Task 和 async 函数的关系? | 进阶 | ★★★★ |
| 07.6.2-005 | Combine 与 async/await 怎么互操作? | 进阶 | ★★★ |
| 07.6.2-006 | 什么是 actor?为什么需要 actor? | 进阶 | ★★★★ |
| 07.6.2-007 | Sendable 协议是什么? | 进阶 | ★★★ |
| 07.6.2-008 | 如何取消一个异步任务? | 基础 | ★★★ |
| 07.6.2-009 | Future 和 Promise 在 Combine 中是什么? | 进阶 | ★★★ |
| 07.6.2-010 | 常见的 Combine Operator 有哪些? | 基础 | ★★★ |
07.6.2-001 Combine 的核心概念是什么?
频率 ★★★★★ | 难度 基础
一句话结论
Combine 是 Apple 的函数式响应式框架:Publisher 发布值序列,Subscriber 订阅并接收值/完成/错误事件;中间用 Operator(map、filter、flatMap 等)转换数据流;Cancellable 用来取消订阅,防止内存泄漏。
概念解释
- Publisher:
Output和Failure关联类型,发布 0 到多个值,最后 .finished 或 .failure。 - Subscriber:通过
sink或assign接收事件。 - Operator:链式调用,把上游值转换后给下游。
- Cancellable:订阅返回的令牌,存储起来,deinit 时 cancel。
代码 / 示例
import Combine
let publisher = [1, 2, 3, 4, 5].publisher
let cancellable = publisher
.map { $0 * 2 }
.filter { $0 > 4 }
.sink(
receiveCompletion: { completion in
print("完成: \(completion)")
},
receiveValue: { value in
print("值: \(value)")
}
)
// 输出: 6, 8, 10
常见误区
- 误区:Combine 订阅不持有会立即释放;正解:sink 返回的 Cancellable 必须存储,否则订阅立即取消。
- 误区:Combine 是异步的;正解:默认同步,异步取决于上游(如网络请求是异步的)。
追问 / 延伸
- 为什么叫 Combine?多个 Publisher 可以组合(merge、zip、combineLatest)。
- Combine 和 RxSwift 的区别?Combine 是 Apple 原生,RxSwift 是第三方,API 类似但 Combine 与 SwiftUI 深度集成。
07.6.2-002 @Published 是怎么工作的?
频率 ★★★★ | 难度 基础
一句话结论
@Published 是一个属性包装器,给属性自动生成一个 Publisher:属性值变化时,新值自动发送给订阅者;在 SwiftUI 中,@Published 属性变化会触发观察它的 View 重新计算 body。
概念解释
- @Published 底层是 CurrentValueSubject,有当前值。
- 用
$前缀可以拿到 Publisher(如$count)。 - 在 ObservableObject 中,@Published 属性变化自动调用 objectWillChange.send()。
代码 / 示例
class ViewModel: ObservableObject {
@Published var count = 0
}
let vm = ViewModel()
cancellable = vm.$count
.sink { print("count 变成 \($0)") }
vm.count = 1 // 输出 "count 变成 1"
vm.count = 2 // 输出 "count 变成 2"
常见误区
- 误区:@Published 是属性观察器(didSet);正解:它是 Combine Publisher,通过 $ 暴露。
- 误区:@Published 在 struct 里也能用;正解:@Published 主要在 class(ObservableObject)中使用。
追问 / 延伸
- @Published 和 didSet 的区别?@Published 可以订阅异步事件流,didSet 只是同步回调。
- 如何在赋值时不触发?直接修改底层 _value 属性(不推荐)。
07.6.2-003 async/await 解决了什么问题?
频率 ★★★★★ | 难度 基础
一句话结论
async/await 用同步的写法写异步代码,消除了 delegate 回调、Completion Handler 嵌套地狱、@escaping 闭包的内存管理负担;编译器自动处理挂起和恢复,代码可读性和安全性大幅提升。
概念解释
- async 函数可以挂起(suspend)而不阻塞线程,挂起时释放线程去做其他工作。
- await 标记挂起点:等待异步结果时,当前线程不阻塞,其他任务可以执行。
- 错误处理用 try/catch,与同步代码一致。
代码 / 示例
// 旧方式:Completion Handler
func fetchUser(id: String, completion: @escaping (Result<User, Error>) -> Void) {
URLSession.shared.dataTask(with: url) { data, _, error in
if let error = error {
completion(.failure(error))
} else if let data = data {
completion(.success(try! JSONDecoder().decode(User.self, from: data)))
}
}.resume()
}
// 新方式:async/await
func fetchUser(id: String) async throws -> User {
let (data, response) = try await URLSession.shared.data(from: url)
guard let httpResponse = response as? HTTPURLResponse,
httpResponse.statusCode == 200 else {
throw NetworkError.badResponse
}
return try JSONDecoder().decode(User.self, from: data)
}
// 调用
do {
let user = try await fetchUser(id: "123")
print(user)
} catch {
print("错误: \(error)")
}
常见误区
- 误区:async 函数在后台线程运行;正解:默认在当前调用线程的异步上下文中,不保证在哪个线程。
- 误区:await 会阻塞线程;正解:await 是挂起(suspend),线程可以去做其他工作。
追问 / 延伸
- async/await 是 iOS 几开始支持?iOS 15+(Swift 5.5)。
- 如何在 iOS 13/14 上用 async/await?用第三方库(如 swift-async-algorithms)或 await 包装器。
07.6.2-004 Task 是什么?Task 和 async 函数的关系?
频率 ★★★★ | 难度 进阶
一句话结论
Task 是异步任务的单元:async 函数必须在异步上下文中调用,Task { ... } 创建一个异步上下文来运行闭包;Task 可以取消、可以指定优先级、可以 await 结果;SwiftUI 中 .task { } 修饰符自动管理 Task 生命周期。
概念解释
- Task 是结构化并发的基础:每个 Task 有自己的执行上下文。
- Task 可以取消:调用 cancel(),异步函数内部需要检查 Task.isCancelled 或 throw CancellationError。
- SwiftUI 的 .task 修饰符:视图出现时启动 Task,视图消失时自动取消。
代码 / 示例
struct ContentView: View {
@State var items: [Item] = []
var body: some View {
List(items) { item in
Text(item.title)
}
.task {
// 视图出现时加载数据
// 视图消失时自动取消
do {
items = try await fetchItems()
} catch {
print(error)
}
}
}
}
// 手动创建 Task
let task = Task {
let result = try await fetchData()
return result
}
// 取消
task.cancel()
常见误区
- 误区:Task 在后台线程运行;正解:Task 默认继承当前执行上下文的线程主队列。
- 误区:Task 不需要管理;正解:不取消的 Task 可能在视图消失后还在运行,造成内存泄漏。
追问 / 延伸
- TaskGroup 是什么?可以并发执行多个子任务,等待全部完成。
- 如何指定 Task 优先级?Task(priority: .userInitiated) { ... }。
07.6.2-005 Combine 与 async/await 怎么互操作?
频率 ★★★ | 难度 进阶
一句话结论
Publisher 可以用 .values 属性转成 AsyncSequence 用 for-await 循环消费;async 函数可以用 Future 包装成 Publisher;新项目推荐用 async/await 为主,Combine 主要用于与 SwiftUI 状态绑定的场景。
概念解释
- AsyncSequence:异步值序列,可以用
for try await value in publisher.values迭代。 - Future:把 async 函数包装成 Publisher,只发一个值然后完成。
- 迁移策略:网络请求、数据获取用 async/await;视图状态绑定保留 @Published。
代码 / 示例
// Publisher -> AsyncSequence
let publisher = NotificationCenter.default.publisher(for: .didLogin)
Task {
for await notification in publisher.values {
print("收到通知: \(notification)")
}
}
// async 函数 -> Publisher
func fetchUser() -> AnyPublisher<User, Error> {
Future { promise in
Task {
do {
let user = try await fetchUserFromNetwork()
promise(.success(user))
} catch {
promise(.failure(error))
}
}
}
.eraseToAnyPublisher()
}
常见误区
- 误区:完全抛弃 Combine 迁移到 async/await;正解:@Published 与 SwiftUI 的绑定仍然很自然,两者共存。
- 误区:AsyncSequence 和 Publisher 完全一样;正解:AsyncSequence 是拉取(pull),Publisher 是推送(push)。
追问 / 延伸
- 如何背压?Combine 支持 Demand 背压,AsyncSequence 没有显式背压。
- 新项目用什么?推荐 async/await + @Published,Combine 只在需要复杂数据流操作时用。
07.6.2-006 什么是 actor?为什么需要 actor?
频率 ★★★★ | 难度 进阶
一句话结论
actor 是 Swift 并发中的一种引用类型,与 class 类似但自带隔离机制:actor 的属性只能在自己的隔离域内访问,跨域访问必须通过 await,编译器自动保证同一时间只有一个任务访问 actor 状态,从根本上防止数据竞争。
概念解释
- 数据竞争:多个线程同时读写同一块内存,导致未定义行为。
- actor 隔离:actor 的所有存储属性默认是隔离的,外部不能直接访问。
- 与队列(DispatchQueue)的区别:actor 由编译器自动管理,不需要手动加锁,不会忘记加锁。
代码 / 示例
actor Counter {
private var value = 0
func increment() {
value += 1 // 安全,因为 actor 内部串行执行
}
func getValue() -> Int {
value
}
}
// 使用
let counter = Counter()
await counter.increment() // 跨域访问需要 await
let current = await counter.getValue()
常见误区
- 误区:actor 是异步的所以慢;正解:actor 内部执行是同步的,只有跨域访问才挂起。
- 误区:所有 class 都应该改成 actor;正解:单线程访问的类不需要 actor,只有多线程共享状态才需要。
追问 / 延伸
- 非隔离方法是什么?actor 中用 nonisolated 标记的方法不需要 await,可以直接调用。
- actor 和 serial queue 哪个好?actor 由编译器保证安全,队列需要手动管理,actor 是现代方案。
07.6.2-007 Sendable 协议是什么?
频率 ★★★ | 难度 进阶
一句话结论
Sendable 是一个标记协议,表示类型可以安全地跨并发域传递;值类型(struct、enum)默认是 Sendable,引用类型(class)需要满足条件(不可变、或者内部用 actor/锁保护)才能标记为 Sendable。
概念解释
- 编译器在跨并发域传递值时检查是否 Sendable,不满足会报警告。
- Sendable 的目的:防止在并发域之间传递可变共享状态。
- 常见的 Sendable 类型:String、Int、Array、Dictionary(值类型)、actor、@unchecked Sendable 的类。
代码 / 示例
// 值类型自动 Sendable
struct User: Sendable {
let name: String
let age: Int
}
// 类需要手动声明 Sendable(必须不可变)
final class Settings: @unchecked Sendable {
private var _settings: [String: String] // 内部用锁保护
private let queue = DispatchQueue(label: "settings")
func get(key: String) -> String? {
queue.sync { _settings[key] }
}
}
常见误区
- 误区:@unchecked Sendable 随便加;正解:必须自己保证线程安全,编译器不再检查。
- 误区:所有 class 都加 Sendable;正解:只有真正线程安全的才加。
追问 / 延伸
- 为什么有 @unchecked?有些类型已经用 GCD/锁保护,但编译器不知道,手动告诉编译器。
- Sendable 是运行时检查吗?不是,是编译时检查,没有运行时开销。
07.6.2-008 如何取消一个异步任务?
频率 ★★★ | 难度 基础
一句话结论
调用 Task 的 cancel() 方法,异步函数内部通过 Task.isCancelled 检查或 try Task.checkCancellation() 主动响应取消;不检查的 Task 会运行到完成,但 SwiftUI 的 .task 修饰符在视图消失时自动取消。
概念解释
- 取消是协作式的:Task 标记为取消,异步代码自己决定在哪里停下来。
- 不会强制中断:正在执行的代码(如大循环)不会自动停止,需要主动检查。
- 取消后调用 checkCancellation() 会抛 CancellationError。
代码 / 示例
func downloadFile(url: URL) async throws -> Data {
let task = Task {
let (data, _) = try await URLSession.shared.data(from: url)
return data
}
// somewhere else:
task.cancel()
do {
let data = try await task.value
return data
} catch is CancellationError {
// 任务被取消
return Data()
}
}
常见误区
- 误区:cancel() 立即停止任务;正解:只是标记,需要任务自己检查。
- 误区:不需要处理取消;正解:长任务不响应取消会浪费资源,视图消失后还在跑。
追问 / 延伸
- 如何在循环中响应取消?每次循环检查
Task.isCancelled,如果是就 break。 - URLSession 的 dataTask 会响应取消吗?会,URLSession 内部支持取消。
07.6.2-009 Future 和 Promise 在 Combine 中是什么?
频率 ★★★ | 难度 进阶
一句话结论
Future 是一个 Publisher,只发一个值或一个错误然后完成;用于包装异步操作(如网络请求),把回调式 API 转成 Combine 流;Promise 是 Future 内部的回调,用来发送结果。
概念解释
- Future 继承 Publisher,Output 是成功值,Failure 是错误。
- 初始化时传入闭包,闭包接收一个 promise 闭包,调用 promise(.success(value)) 或 promise(.failure(error))。
- Future 是冷的:订阅时才执行闭包。
代码 / 示例
func fetchUser(id: String) -> Future<User, Error> {
Future { promise in
URLSession.shared.dataTask(with: url) { data, _, error in
if let error = error {
promise(.failure(error))
} else if let data = data {
do {
let user = try JSONDecoder().decode(User.self, from: data)
promise(.success(user))
} catch {
promise(.failure(error))
}
}
}.resume()
}
}
// 使用
cancellable = fetchUser(id: "123")
.receive(on: DispatchQueue.main)
.sink(
receiveCompletion: { print($0) },
receiveValue: { user in print(user) }
)
常见误区
- 误区:Future 可以发多个值;正解:Future 只发一个值就完成。
- 误区:Future 是热的;正解:Future 是冷的,订阅才执行。
追问 / 延伸
- Future 和 async/await 的关系?Future 可以用 async/await 重写(见 07.6.2-005)。
- AnyPublisher 是什么?类型擦除,隐藏具体 Publisher 类型,对外只暴露 AnyPublisher<Output, Failure>。
07.6.2-010 常见的 Combine Operator 有哪些?
频率 ★★★ | 难度 基础
一句话结论
常用 Operator:map(转换值)、filter(过滤)、flatMap(扁平化嵌套流)、receive(on:)/subscribe(on:)(切换线程)、catch(错误处理)、replaceNil(with:)、removeDuplicates()、combineLatest(合并多个流)、zip(配对)、debounce(防抖)。
概念解释
- map:把值转成另一个值,类似 Swift 标准库的 map。
- flatMap:把每个值转成一个 Publisher,然后把所有 Publisher 的输出合并。
- receive(on:):决定下游在哪个线程接收值(通常是 .main 用于 UI 更新)。
- debounce:防抖,输入停止一段时间后才发值,适合搜索框。
代码 / 示例
// 搜索防抖
searchTextField.textPublisher
.debounce(for: .milliseconds(300), scheduler: DispatchQueue.main)
.removeDuplicates()
.flatMap { query in
self.search(query: query) // 返回 AnyPublisher<[Result], Error>
}
.receive(on: DispatchQueue.main)
.sink(
receiveCompletion: { _ in },
receiveValue: { results in
self.results = results
}
)
.store(in: &cancellables)
常见误区
- 误区:所有 Operator 都在后台线程执行;正解:默认在当前线程,需要用 receive(on:) 切换。
- 误区:忘记 receive(on: .main);正解:网络请求结果默认在后台线程,更新 UI 必须切回主线程。
追问 / 延伸
- map 和 flatMap 的区别?map 返回值,flatMap 返回 Publisher。
- 如何处理错误不让流中断?用 catch 或 tryCatch 返回一个默认 Publisher。
待整理清单
- [ ] Combine 与 RxSwift 的详细对比
- [ ] Structured Concurrency(TaskGroup、async let)
- [ ] 内存泄漏在 Combine 中的常见模式