罗罗编程学习记录
本页内容 展开查看

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 中的常见模式