Combine-Future

前面我们用过Just，其数据的发布和订阅是同步行为。如果希望数据的发布和订阅是异步的，可以使用Future。Future可以创建一个接收未来数据与事件的 Publisher。Future定义如下：

final public class Future<Output, Failure> : Publisher where Failure : Error {

    public typealias Promise = (Result<Output, Failure>) -> Void
    
    public init(_ attemptToFulfill: @escaping (@escaping Future<Output, Failure>.Promise) -> Void)
    
    final public func receive<S>(subscriber: S) where Output == S.Input, Failure == S.Failure, S : Subscriber
}

• Future 是一次性的且非 lazy 的，它会在初始化时立刻执行闭包，需要存储处理 Promise 中的值，发给当前和未来的一个或多个 Subscriber。一旦产生一个数据或失败时，Future 会立即结束。
• Future 适用于那些必然会产生事件结果且至多只会产生一个结果的场景。

Promise

从上面的定义可以看出，其本质是(Result<Output, Failure>) -> Void的类型别名，它表示 Future 的最终结果。

成功的处理

import UIKit
import Combine

let future = Future<Int, Never> { promise in
    
    DispatchQueue.main.asyncAfter(deadline: .now() + 3) {
        promise(.success(100))
    }
}

let subscription = future.sink(receiveValue: { value in
    print(value)
})

失败的处理

import UIKit
import Combine

struct SomeError: Error {
}

let future = Future<Int, SomeError> { promise in
    
    DispatchQueue.main.asyncAfter(deadline: .now() + 3) {
        promise(.failure(SomeError()))
    }
}

let subscription = future.sink(receiveCompletion: { completion in
    if case .failure(let error) = completion {
        // 失败的处理
        print(error)
    }
}, receiveValue: { _ in
    // 成功的处理
})

基本使用

import Combine

// 返回一个Future对象且会产生一个Int类型的值
func createFuture() -> Future<Int, Never> {
    // 返回一个Future，它是一个闭包
    // 在该闭包里执行异步操作，只会执行一次
    return Future { promise in
        // 异步操作
        
        // 最后必须调用promise完成工作
        promise(.success(100))
    }
}

createFuture().sink(receiveValue: { value in
    print(value)
})

/*输出
 100
 */

说明

1. 当创建一个 Future 时，它会立即开始执行。
2. Future 将只运行一次提供的闭包。
3. 多次订阅同一个 Future 将返回同一个结果。