You need to enable JavaScript to run this app. 在Combine的Future创建闭包外持有并resolve promise的用法是否正确?
优惠活动
大模型
产品
解决方案
定价
更多

在Combine的Future创建闭包外持有并resolve promise的用法是否正确?

合法性结论

你这种存储Future Promise的用法完全符合Combine的设计规范,不存在违规问题。Future的核心设计目标就是支持异步生成单个结果,官方本身就允许在创建闭包之外的时机调用Promise,你当前的用法是合理的。

现有实现的潜在问题

你当前的代码存在一个明显的缺陷:如果有多个调用方先后调用getApples()或getBananas()方法,后生成的Promise会覆盖你之前存储的Promise属性,最终只有最后一个调用方可以收到结果,之前的所有调用方都会永久收不到回调。

更优的实现方案

根据你的业务场景,有两种常用的优化方案:

方案1:存储Promise数组(适配只返回一次结果的场景)

如果你的收割事件只会触发一次,且需要支持多个调用方同时订阅获取结果,可以把Promise的存储从单个变量改成数组,每次调用方法就把新生成的Promise加入数组,触发结果时遍历所有Promise逐一调用:

class FruitBroker {
    // MARK: - Private Properties
    private var applePromises: [Future<[Apple], Never>.Promise] = []
    private var orangePromises: [Future<[Orange], Never>.Promise] = []
    private var apples: [Apple] = []
    private var oranges: [Orange] = []
    private var isHarvested = false

    // MARK: - Methods
    func getApples() -> AnyPublisher<[Apple], Never> {
        // 如果已经收割完成,直接返回已有结果
        if isHarvested {
            return Just(apples).eraseToAnyPublisher()
        }
        return Future<[Apple], Never> { promise in
           self.applePromises.append(promise)
        }.eraseToAnyPublisher()
    }

    func getOranges() -> AnyPublisher<[Orange], Never> {
        if isHarvested {
            return Just(oranges).eraseToAnyPublisher()
        }
        return Future<[Orange], Never> { promise in
           self.orangePromises.append(promise)
        }.eraseToAnyPublisher()
    }

    // MARK: - Private Methods
    private func onHarvestFinished() {
        isHarvested = true
        applePromises.forEach { $0(.success(apples)) }
        orangePromises.forEach { $0(.success(oranges)) }
        // 清空数组释放内存
        applePromises.removeAll()
        orangePromises.removeAll()
    }
}

方案2:使用Subject实现(适配可能多次触发结果的场景)

如果你的业务后续可能支持多次收割事件,直接使用PassthroughSubject会更简洁,不需要每次创建Future,订阅逻辑更直观:

class FruitBroker {
    // MARK: - Private Properties
    private let appleSubject = PassthroughSubject<[Apple], Never>()
    private let orangeSubject = PassthroughSubject<[Orange], Never>()
    private var apples: [Apple] = []
    private var oranges: [Orange] = []

    // MARK: - Methods
    func getApples() -> AnyPublisher<[Apple], Never> {
        appleSubject.eraseToAnyPublisher()
    }

    func getOranges() -> AnyPublisher<[Orange], Never> {
        orangeSubject.eraseToAnyPublisher()
    }

    // MARK: - Private Methods
    private func onHarvestFinished() {
        appleSubject.send(apples)
        orangeSubject.send(oranges)
        // 如果收割只触发一次,可以调用send()后直接发送finished事件
        appleSubject.send(completion: .finished)
        orangeSubject.send(completion: .finished)
    }
}

额外注意点

不管使用哪种方案,都建议保证对Promise数组/Subject的操作都在同一个串行队列中执行,避免多线程竞争导致的异常问题。

内容的提问来源于stack exchange,提问作者Claudio

相关产品推荐
方舟 Agent Plan

超全模态模型 × Harness 升级,最新支持 Deepseek-V4.1-Flash、GLM-5.3 系列、Doubao-Seedream-5.0-pro、Kimi-K3 (部分), 限时 9.9 元起

最近更新时间:2026.10.17 04:36:03