Swift之深入解析如何实现Promise

Posted Forever_wj

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Swift之深入解析如何实现Promise相关的知识,希望对你有一定的参考价值。

一、前言

  • 异步编程是开发 App 的一个难点,多线程操作,线程的切换,多层嵌套 callback,使得代码十分的混乱,难以理解。
func load(_ callback: (Value) -> Void) {
     loadService.load { result in
         let saveableItem = result.transfromToSaveableItem
         saveQueue.async {
              saveService.save(saveableItem) { saved in
                  let displayableItem = saved.tranfromToDisplayableItem
                   mainQueue.async {
                       callback(displayableItem)
                   }              
              }
         }
     }
}
  • Github 有很多直接或者间接能解决这个问题的方案,比如 RxSwift 等函数响应式编程框架,通过 observeOn,可以轻松的切换线程,并且使用 map,flatmap 等操作符链式的操作结果,可以让我们轻松的写出结构清晰的代码。具体可以参考我的专栏:RAC+RxSwift
  • Promise 是一种链接异步任务的方式,有三大要素:
    • 保存当前状态的 State;
    • 保存回调函数的 Callbacks;
    • 控制线程安全的方式。
  • 通常来说,异步任务会在异步操作完成时执行回调闭包(有时候要准备两个闭包,一个代表成功,一个代表失败)。要执行多个异步操作,必须将第二个异步操作放在第一个异步操作的完成闭包中执行:
APIClient.fetchCurrentUser(success: { currentUser in
	APIClient.fetchFollowers(user: currentUser, success: { followers in
		// 得到一个 followers 数组
	}, failure: { error in
		// 错误处理
	})
}, failure: { error in
	// 错误处理
})
  • Promise 的作用是格式化完成闭包,简化链式异步调用的形式。如果系统能够分辨成功和失败,那么组合这些异步操作就变得容易很多。比如,编写具有下列功能的可重用代码:
    • 使用尾闭包执行一系列依赖关系的异步操作;
    • 通过一个完成闭包同时执行多个独立的异步操作;
    • 多个异步操作竞争,返回第一个完成的值;
    • 重试异步操作;
    • 为异步操作设置超时时间。
  • 如上代码转换为 Promise 样式如下:
APIClient.fetchCurrentUser().then({ currentUser in
	return APIClient.fetchFollowers(user: currentUser)
}).then({ followers in
	// you now have an array of followers
)}.onFailure({ error in
	// hooray, a single failure block!
})
  • 可能你也注意到了,Promise 是将嵌套/缩进样式的代码变成一个层级的代码:Promise 是一个 Monad
  • Promise 在 javascript 社区中反响热烈,因为 Node.js 的设计中包含了非常多异步操作,即便是简单的任务也需要用到链式的异步回调,即便只有三四个这样的操作,代码会变得笨重。Promise 终结了提心吊胆写回调的日子,Promise 已经写进了 JavaScript ES6 的规范。JavaScript Promise 的运作机制请参考:JavaScript Promises … in Wicked Detail
  • JavaScript Promise 实现的一个亮点是它有一个非常明确的规范,称为 A+,具体详情可以在 promisejs.org查看,这意味着依赖 JavaScript 的弱类型系统,多个 Promise 的实现可以融合,彼此之间可以互相操作。只要 Promise 中的 then 函数定义符合规范,它就可以和其他库中的 Promise 连接,这实在是太棒了。
  • A+ 规范有一个非常好的 API,不使用 monad 中那个命名简单且易于理解的 then 方法(在 A+ 规范中被重构为 flatMap 和 map)。不过这个 API 不适合每个人,但我真的很喜欢它,并开始在 Swift 中实现一个类似的库。你可以在 Github 的 Promise 上找个到这个库,编写的过程很具有启发性。

二、枚举

var PENDING = 0;
var FULFILLED = 1;
var REJECTED = 2;

function Promise() {
  // 保存 PENDING, FULFILLED 或者 REJECTED 的状态
  var state = PENDING;

  // 当出现 FULFILLED 或 REJECTED 状态时保存值或者错误
var value = null;

  // 保存被 .then 或者 .done 函数触发的成功 & 失败的处理操作
  var handlers = [];
}
  • 应该是找不到比 Swift 的枚举实现更完美的例子了,如下,是 Swift 中的实现:
enum State<Value> {
    case pending
    case fulfilled(value: Value)
    case rejected(error: ErrorType)
}

final class Promise<Value> {    
    private var state: State<Value>
    private var callbacks: [Callback<Value>] = []
}
  • 外部数据依赖于 Promise 的具体状态,所以被封装到对应 case 的关联值中。当 Promise 处于 .pending 状态时,任何外部数据都没有意义,枚举在类型系统中表达出的语义是不可思议的。唯一要批判的是泛型不能被嵌套进其它类型中,并且这个缺陷在 Swift 3 中不会更改,具体请参考:Nested generic type in function is not allowed

三、类型系统

  • 创建一个新的 JavaScript Promise 时,可以使用便捷构造器:
var promise = new Promise(function(resolve, reject) {
	someAsyncRequest(function(error, result) {
		if (error) {
			reject(error);
		}
		resolve(result);
	});
});
  • 传入了一个包含两个其它函数的函数,主要有两个功能:第一个函数参数对应 Promise 操作成功的情况,第二个对应了失败的情况。这两个函数的顺序很重要,因为 JavaScript 不是类型安全的,如果在上面的第一行代码中写错了顺序,写成了 reject, resolve,很容易就向 resolve 函数中引入了错误。另一方面,Swift 是类型安全的,这意味着 reject 函数的类型是 (ErrorType) -> Void),该函数不会被成功的结果所接受,所以再也不用担心弄乱 reject 和 resolve 函数的顺序。

四、太多的类型可能会令人沮丧

  • Promise 的类型中使用了泛型 Value,这是它的内部值类型,意味着可以通过类型推断而不用指定具体的类型:
let promise = Promise(value: "initialValue") // a fulfilled Promise<String>
  • 因为 Promise 经常被链式调用,依靠类型推断来确定类型将会特别有用,必须向链中的每个步骤添加明确的类型是件令人沮丧的事,最终的样式也不是很有 Swift 的风格:
let promise = Promise<String, APIError>(value: "initialValue")
  • 这使得一行简单的代码增加了很多不必要的包袱,所以我删除了指定错误类型的功能。不幸的是,删除显式的错误类型意味着不得不失去一个小小的类型系统的优势。假设使用了一个叫 NoError 的空枚举,它有效地表达出 Promise 不能失败的语义,因为空的枚举不能被初始化,所以 Promise 不能进入到 rejected 的状态,这是一个令人心痛的损失,但我认为这是值得的,因为这样在其它上下文中使用 Promise 变得更简单,希望能在实践中使用这个类,以便深入体会并思考不设置错误类型否是个明智的决定。

五、函数式编程中的方法难以理解

  • Promise 的类型是一个 monad,也就是说可以对它调用 flatMap,传递给 flatMap 的函数会返回一个新的 Promise,返回的 Promise 的状态将成为该调用链的状态。
  • 不过,flatMap 的函数名是绝对不能忽视的,它无法使用一种易读的方式表达函数中发生的事情,这是 A+ 规范的 Promise API 的优势之一。JavaScript 中的 then 函数被重载为 flatMap 函数(为调用链返回一个新的 Promise)和 map 函数(为调用链中的下一个 Promise 返回一个新值)。then 只意味着“下一步做这件事”,而不知道下一件事情的工作原理。

六、实现 Promise

① 第一个测试

  • 先写第一个测试:
test(named: "0. Executor function is called immediately") { assert, done in
    var string: String = ""
    _ = Promise { string = "foo" }
    assert(string == "foo")
    done()
}
  • 通过此测试,想实现传递一个函数给 Promise 的初始化函数,并立即调用此函数(没有使用任何测试框架,仅仅使用一个自定义的 test 方法,它在 Playground 中模拟断言:PromisePlayground.swift)。
  • 当我们运行 Playground,编译器会报错:
error: Promise.playground:41:9: error: use of unresolved identifier 'Promise'
    _ = Promise { string = "foo" }
        ^~~~~~~
  • 合理,因此需要定义 Promise 类:
class Promise {

}
  • 再运行,错误变为:
error: Promise.playground:44:17: error: argument passed to call that takes no arguments
    _ = Promise { string = "foo" }
                ^~~~~~~~~~~~~~~~~~
  • 必须定义一个初始化函数,它接受一个闭包作为参数,而且这个闭包应该被立即调用:
class Promise {
    init(executor: () -> Void) {
        executor()
    }
}
  • 由此,我们通过第一个测试,目前还没有写出什么值得夸耀的东西,但耐心一点,实现将继续增长:
Test 0. Executor function is called immediately passed 
  • 我们先将此测试注释掉,因为将来的 Promise 实现会变得有些不同。

② 最低限度

  • 第二个测试如下:
test(named: "1.1 Resolution handler is called when promise is resolved sync") { assert, done in
    let string: String = "foo"
    let promise = Promise<String> { resolve in
        resolve(string)
    }
    promise.then { (value: String) in
        assert(string == value)
        done()
    }
}
  • 这个测试挺简单,但添加了一些新内容到 Promise 类,创建的这个 promise 有一个 resolution handler(即闭包的 resolve 参数),之后立即调用它(传递一个 value)。然后使用 promise 的then方法来访问 value 并用断言确保其值。
  • 在开始实现之前,需要引入另外一个不太一样的测试:
test(named: "1.2 Resolution handler is called when promise is resolved async") { assert, done in
    let string: String = "foo"
    let promise = Promise<String> { resolve in
        after(0.1) {
            resolve(string)
        }
    }
    promise.then { (value: String) in
        assert(string == value)
        done()
    }
}
  • 不同于测试 1.1 ,这里的 resove 方法被延迟调用,这意味着,在 then 里,value 不会立马可用(因为 0.1 秒的延迟,调用 then 时,resolve 还未被调用)。
  • 开始理解这里的“问题”,必须处理异步:
    • promise 是一个状态机,当它被创建时,promise 处于pending状态,一旦 resolve 方法被调用(与一个 value),promise 将转到 resolved 状态,并存储这个 value。
    • then 方法可在任意时刻被调用,而不管 promise 的内部状态(即不管 promise 是否已有一个 value),当这个 promise 处于 pending 状态时,调用 then,value 将不可用,因此需要存储此回调,之后一旦 promise 变成 resolved,就能使用 resolved value 来触发同样的回调。
  • 现在对要实现的东西有了更好的理解,那就先以修复编译器的报错开始:
error: Promise.playground:54:19: error: cannot specialize non-generic type 'Promise'
    let promise = Promise<String> { resolve in
                  ^      ~~~~~~~~
  • 必须给 Promise 类型添加泛型,诚然,一个 promise 是这样的东西:它关联着一个预定义的类型,并能在被解决时,将一个此类型的 value 保留住:
class Promise<Value> {

    init(executor: () -> Void) {
        executor()
    }
}
  • 现在错误为:
error: Promise.playground:54:37: error: contextual closure type '() -> Void' expects 0 arguments, but 1 was used in closure body
    let promise = Promise<String> { resolve in
                                    ^
  • 必须提供一个 resolve 函数传递给初始化函数(即 executor):
class Promise<Value> {
    init(executor: (_ resolve: (Value) -> Void) -> Void) {
        executor()
    }
}
  • 注意这个 resolve 参数是一个函数,它消耗一个 value:(Value) -> Void,一旦 value 被确定,这个函数将被外部世界调用。
    编译器依然不开心,因为需要提供一个 resolve 函数给 executor,那就创建一个 private:
class Promise<Value> {
    init(executor: (_ resolve: @escaping (Value) -> Void) -> Void) {
        executor(resolve)
    }

    private func resolve(_ value: Value) -> Void {
        // To implement
        // This will be called by the outside world when a value is determined
    }
}
  • 当所有错误都被解决的时候,再来实现 resolve。下一个错误很简单,方法 then 还未定义:
error: Promise.playground:61:5: error: value of type 'Promise<String>' has no member 'then'
    promise.then { (value: String) in
    ^~~~~~~ ~~~~
  • 现在修复它:
class Promise<Value> {

    init(executor: (_ resolve: @escaping (Value) -> Void) -> Void) {
        executor(resolve)
    }

    func then(onResolved: @escaping (Value) -> Void) {
        // To implement
    }

    private func resolve(_ value: Value) -> Void {
        // To implement
    }
}
  • 现在编译通过,我们之前说过一个 Promise 就是一个状态机,它有一个 pending 状态和一个 resolved 状态,可以使用 enum 来定义它们:
enum State<T> {
    case pending
    case resolved(T)
}
  • Swift 可以直接存储 promise 的 value 在 enum 中,现在我要在 Promise 的实现中定义一个状态,其默认值为 .pending,还需要一个私有函数,它能在当前还处于 .pending 状态时更新状态:
class Promise<Value> {

    enum State<T> {
        case pending
        case resolved(T)
    }

    private var state: State<Value> = .pending

    init(executor: (_ resolve: @escaping (Value) -> Void) -> Void) {
        executor(resolve)
    }

    func then(onResolved: @escaping (Value) -> Void) {
        // To implement
    }

    private func resolve(_ value: Value) -> Void {
        // To implement
    }

    private func updateState(to newState: State<Value>) {
        guard case .pending = state else { return }
        state = newState
    }
}
  • 注意 updateState(to:) 函数先检查了当前处于 .pending 状态,如果 promise 已经处于 .resolved 状态,那它就不能再变成其它状态。
    现在是时候在必要时更新 promise 的状态,即当 resolve 函数被外部世界传递 value 调用时:
private func resolve(_ value: Value) -> Void {
    updateState(to: .resolved(value))
}
  • 现在只缺少 then 方法还未实现,必须存储回调,并在 promise 被解决时调用回调,现在来实现:
class Promise<Value> {

    enum State<T> {
        case pending
        case resolved(T)
    }

    private var state: State<Value> = .pending
    // we store the callback as an instance variable
    private var callback: ((Value) -> Void)?

    init(executor: (_ resolve: @escaping (Value) -> Void) -> Void) {
        executor(resolve)
    }

    func then(onResolved: @escaping (Value) -> Void) {
        // store the callback in all cases
        callback = onResolved
        // and trigger it if needed
        triggerCallbackIfResolved()
    }

    private func resolve(_ value: Value) -> Void {
        updateState(to: .resolved(value))
    }

    private func updateState(to newState: State<Value>) {
        guard case .pending = state else { return }
        state = newState
        triggerCallbackIfResolved()
    }

    private func triggerCallbackIfResolved() {
        // the callback can be triggered only if we have a value,
        // meaning the promise is resolved
        guard case let .resolved(value) = state else { return }
        callback?(value)
        callback = nil
    }
}
  • 这里定义了一个实例变量 callback,以在 promise 处于.pending 状态时保留回调。同时,创建一个方法 triggerCallbackIfResolved,它先检查状态是否为 .resolved,然后传递拆包的 value 给回调,这个方法在两个地方被调用,一个是 then 方法中,如果 promise 已经在调用 then 时被解决;另一个在 updateState 方法中,因为那是 promise 更新其内部状态从 .pending 到 .resolved 的地方。
  • 有了这些修改,测试就成功通过:
Test 1.1 Resolution handler is called when promise is resolved sync passed (1 assertions)
Test 1.2 Resolution handler is called when promise is resolved async passed (1 assertions)
  • 但现在还需要做出一点改变,以得到一个真正的 Promise 实现,先来看看测试:
test(named: "2.1 Promise supports many resolution handlers sync") { assert, done in
    let string: String = "foo"
    let promise = Promise<String> { resolve in
        resolve(string)
    }
    promise.then { value in
        assert(string == value)
    }
    promise.then { value in
        assert(string == value)
        done()
    }
}
test(named: "2.2 Promise supports many resolution handlers async") { assert, done in
    let string: String = "foo"
    let promise = Promise<String> { resolve in
        after(0.1) {
            resolve(string)
        }
    }
    promise.then { value in
        assert(string == value)
    }
    promise.then { value in
        assert(string == value)
        done()
    }
}
  • 这回对每个 promise 都调用了两次 then,看看测试输出:
Test 2.1 Promise supports many resolution handlers sync passed (2 assertions)
Test 2.2 Promise supports many resolution handlers async passed (1 assertions)
  • 虽然测试通过了,但你可能也注意问题,测试 2.2 只有一个断言,但应该是两个。如果思考一下,这其实符合逻辑,在异步的测试 2.2 中,当第一个 then 被调用时,promise 还处于 .pending 状态,如之前所见,存储了第一次 then 的回调,但当第二次调用 then 时,promise 还是没有被解决,依然处于 .pending 状态,于是将回调擦除换成了新的。只有第二个回调会在将来被执行,第一个被忘记了,这使得测试虽然通过,但只有一个断言而不是两个。
  • 解决办法也很简单,就是存储一个回调的数组,并在 promise 被解决时触发它们,更新一下:
class Promise<Value> {

    enum State<T> {
        case pending
        case resolved(T)
    }

    private var state: State以上是关于Swift之深入解析如何实现Promise的主要内容,如果未能解决你的问题,请参考以下文章

Swift之深入解析如何将代码添加为自定义LLDB命令

Swift之深入解析如何使用并发系统并行运行多个任务

Swift之深入解析Sendable和@Sendable闭包代码实例

Swift之深入解析Sendable和@Sendable闭包代码实例

Swift之深入解析Sendable和@Sendable闭包代码实例

Swift之深入解析如何使用Xcode和LLDB v2修改UI元素