SwiftUI Combine中如何基于API响应依次同步执行多任务？

要在保留当前多sink结构的前提下，让task1、task2、task3按顺序执行，你可以借助Combine的信号依赖特性，把每个任务包装成可传递完成信号的Publisher，再通过链式调用控制执行顺序，同时保留share()复用API响应的优势。

1. 把任务包装成返回Publisher的函数 #

先把每个任务改成返回AnyPublisher的函数，这样任务完成时会发送信号，触发下一个任务：

func runTask1() -> AnyPublisher<Void, Error> {
    return Future { promise in
        // 这里写task1的执行逻辑
        print("执行task1")
        promise(.success(()))
    }
    .eraseToAnyPublisher()
}

func runTask2() -> AnyPublisher<Void, Error> {
    return Future { promise in
        // 这里写task2的执行逻辑
        print("执行task2")
        promise(.success(()))
    }
    .eraseToAnyPublisher()
}

func runTask3() -> AnyPublisher<Void, Error> {
    return Future { promise in
        // 这里写task3的执行逻辑
        print("执行task3")
        promise(.success(()))
    }
    .eraseToAnyPublisher()
}

2. 基于共享API响应构建顺序执行链 #

通过flatMap把任务串联起来，每个后续任务等待前一个完成后再执行，同时保留原有的sink结构：

// 共享API响应，确保只请求一次
let apiShared = apiPublisher
    .subscribe(on: DispatchQueue.global())
    .receive(on: DispatchQueue.main)
    .share()

// 任务1完成信号：订阅API响应，执行task1
let task1Done = apiShared
    .flatMap { _ in runTask1() }
    .share()

// 任务2完成信号：等待task1完成后执行task2
let task2Done = task1Done
    .flatMap { _ in runTask2() }
    .share()

// 任务3：等待task2完成后执行task3
let _ = task2Done
    .sink(receiveCompletion: { _ in }, receiveValue: { _ in
        _ = runTask3().sink(receiveCompletion: { _ in }, receiveValue: { _ in })
    })
    .store(in: &cancellables)

// 保留原有的三个sink，可用于其他逻辑（比如UI更新、日志）
let _ = apiShared
    .sink { _ in
        // 比如标记API响应已接收
    }
    .store(in: &cancellables)

let _ = task1Done
    .sink { _ in
        // 比如task1完成后的状态更新
    }
    .store(in: &cancellables)

let _ = task2Done
    .sink { _ in
        // 比如task2完成后的状态更新
    }
    .store(in: &cancellables)

3. 更简洁的写法：用handleEvents绑定顺序 #

如果不想拆分多个Publisher，也可以在共享的API链中用handleEvents触发顺序任务，原sink保留做其他处理：

let test = apiPublisher
    .subscribe(on: DispatchQueue.global())
    .receive(on: DispatchQueue.main)
    .handleEvents(receiveOutput: { _ in
        // 按顺序执行三个任务
        runTask1()
            .flatMap { _ in runTask2() }
            .flatMap { _ in runTask3() }
            .sink(receiveCompletion: { _ in }, receiveValue: { _ in })
            .store(in: &cancellables)
    })
    .share()

// 原有的三个sink结构完全保留，用于各自的逻辑
test
    .sink { _ in
        // do task1相关的辅助操作（比如日志）
    }.store(in: &cancellables)

test
    .sink { _ in
        // do task2相关的辅助操作
    }.store(in: &cancellables)

test
    .sink { _ in
        // do task3相关的辅助操作
    }.store(in: &cancellables)

关键说明 #

• share()确保API请求只发起一次，所有订阅者共用同一个响应结果。
• 用flatMap串联任务时，只有前一个任务的Publisher发送完成信号，才会启动下一个任务，严格保证顺序。
• 原有的三个sink可以继续保留，用来处理和任务执行顺序无关的逻辑，比如UI状态更新、日志记录等，和顺序执行的任务逻辑解耦。

内容的提问来源于stack exchange，提问作者arun siva