如何确保 'start' 一起完成的两个异步任务在另一个运行之前完成？

Question

我正在设置一个应用程序，它利用 promiseKit 作为订购异步任务的方式。我目前有一个设置可确保按顺序完成两个异步函数（称为 promises）（让我们称它们为 1 和 2），并确保另一组函数（3 和 4）按顺序完成。大致：

import PromiseKit
override func viewDidAppear(_ animated: Bool) {


        firstly{
            self.promiseOne() //promise #1 happening first (in relation to # 1 and #2)
            }.then{_ -> Promise<[String]> in
                self.promiseTwo()//promise #2 starting after 1 has completed
            }
            .catch{ error in
                print(error)
        }
        firstly{
            self.promiseThree()//Promise #3 happening first (in relation to #3 and #4)
            }.then{_ -> Promise<[String]> in
                self.promiseFour()//Promise #4 starting after #3 has completed
            }.
            .catch{ error in
                print(error)
        }
}

每个 firstly 通过确保第一个函数在第二个函数启动之前完成来确保其中函数的顺序。使用两个单独的 firstly 确保 1 在 2 之前完成，3 在 4 之前完成，和（重要的是）1 和 3 大致同时开始（在viewDidAppear() 的开始）。这是有意为之的，因为 1 和 3 彼此不相关，可以同时启动而不会出现任何问题（2 和 4 也是如此）。问题是有第五个承诺，让我们称之为 promiseFive 必须 only be 运行 after 2 和4个已经完成。我可以 link 一个 firstly 确保顺序为 1,2,3,4,5，但由于 1/2 和 3/4 的顺序不相关，link以这种方式阅读它们会浪费时间。我不确定如何设置它，以便 promiseFive 在 2 和 4 完成后仅运行。我想过在 2 和 4 的末尾调用布尔检查函数，确保其他 firstly 已完成然后调用 promiseFive 但是，由于它们 begin 异步（1/2 和 3/4），有可能 promiseFive 使用这种方法会同时被两者调用，这显然会产生问题。解决此问题的最佳方法是什么？

Answer 1

您可以使用 when or join 在多个其他承诺完成后开始某事。不同之处在于他们如何处理失败的承诺。听起来你想加入。这是一个具体但简单的示例。

第一个代码块是一个示例，说明如何创建 2 个 promise 链，然后在开始下一个任务之前等待它们都完成。实际完成的工作被抽象成一些功能。关注此代码块，因为它包含您需要的所有概念信息。

片段

let chain1 = firstly(execute: { () -> (Promise<String>, Promise<String>) in
    let secondPieceOfInformation = "otherInfo" // This static data is for demonstration only

    // Pass 2 promises, now the next `then` block will be called when both are fulfilled
    // Promise initialized with values are already fulfilled, so the effect is identical
    // to just returning the single promise, you can do a tuple of up to 5 promises/values
    return (fetchUserData(), Promise(value: secondPieceOfInformation))

}).then { (result: String, secondResult: String) -> Promise<String> in
    self.fetchUpdatedUserImage()
}

let chain2 = firstly {
    fetchNewsFeed() //This promise returns an array

}.then { (result: [String : Any]) -> Promise<String> in

    for (key, value) in result {
        print("\(key) \(value)")
    }
    // now `result` is a collection
    return self.fetchFeedItemHeroImages()
}

join(chain1, chain2).always {
    // You can use `always` if you don't care about the earlier values

    let methodFinish = Date()
    let executionTime = methodFinish.timeIntervalSince(self.methodStart)
    print(String(format: "All promises finished %.2f seconds later", executionTime))
}

PromiseKit 使用 closures 提供它的 API。闭包的范围就像 if 语句一样。如果您在 if 语句的范围内定义一个值，那么您将无法在该范围之外访问它。

您有多种选择可以将多条数据传递到下一个 then 块。

使用与所有承诺共享一个范围的变量（您可能希望避免这种情况，因为它在管理异步数据传播流时对您不利）
使用自定义数据类型来保存两个（或更多）值。这可以是元组、结构、class 或枚举。
使用集合（如字典），例子在chain2
Return 承诺元组，示例包含在 chain1

您在选择方法时需要做出最佳判断。

完整代码

import UIKit
import PromiseKit

class ViewController: UIViewController {

    let methodStart = Date()

    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)

        <<Insert The Other Code Snippet Here To Complete The Code>>

        // I'll also mention that `join` is being deprecated in PromiseKit
        // It provides `when(resolved:)`, which acts just like `join` and
        // `when(fulfilled:)` which fails as soon as any of the promises fail
        when(resolved: chain1, chain2).then { (results) -> Promise<String> in
            for case .fulfilled(let value) in results {
                // These promises succeeded, and the values will be what is return from
                // the last promises in chain1 and chain2
                print("Promise value is: \(value)")
            }

            for case .rejected(let error) in results {
                // These promises failed
                print("Promise value is: \(error)")
            }

            return Promise(value: "finished")
            }.catch { error in
                // With the caveat that `when` never rejects
        }
    }

    func fetchUserData() -> Promise<String> {
        let promise = Promise<String> { (fulfill, reject) in

            // These dispatch queue delays are standins for your long-running asynchronous tasks
            // They might be network calls, or batch file processing, etc
            // So, they're just here to provide a concise, illustrative, working example
            DispatchQueue.global().asyncAfter(deadline: .now() + 2.0) {
                let methodFinish = Date()
                let executionTime = methodFinish.timeIntervalSince(self.methodStart)

                print(String(format: "promise1 %.2f seconds later", executionTime))
                fulfill("promise1")
            }
        }

        return promise
    }

    func fetchUpdatedUserImage() -> Promise<String> {
        let promise = Promise<String> { (fulfill, reject) in
            DispatchQueue.global().asyncAfter(deadline: .now() + 2.0) {
                let methodFinish = Date()
                let executionTime = methodFinish.timeIntervalSince(self.methodStart)

                print(String(format: "promise2 %.2f seconds later", executionTime))
                fulfill("promise2")
            }
        }

        return promise
    }

    func fetchNewsFeed() -> Promise<[String : Any]> {
        let promise = Promise<[String : Any]> { (fulfill, reject) in
            DispatchQueue.global().asyncAfter(deadline: .now() + 1.0) {
                let methodFinish = Date()
                let executionTime = methodFinish.timeIntervalSince(self.methodStart)

                print(String(format: "promise3 %.2f seconds later", executionTime))
                fulfill(["key1" : Date(),
                         "array" : ["my", "array"]])
            }
        }

        return promise
    }

    func fetchFeedItemHeroImages() -> Promise<String> {
        let promise = Promise<String> { (fulfill, reject) in
            DispatchQueue.global().asyncAfter(deadline: .now() + 2.0) {
                let methodFinish = Date()
                let executionTime = methodFinish.timeIntervalSince(self.methodStart)

                print(String(format: "promise4 %.2f seconds later", executionTime))
                fulfill("promise4")
            }
        }

        return promise
    }
}

输出

promise3 1.05 seconds later
array ["my", "array"]
key1 2017-07-18 13:52:06 +0000
promise1 2.04 seconds later
promise4 3.22 seconds later
promise2 4.04 seconds later
All promises finished 4.04 seconds later
Promise value is: promise2
Promise value is: promise4

Answer 2

细节在一定程度上取决于这些不同承诺的类型，但您基本上可以 return 承诺 1 后接 2 作为一个承诺，return 承诺后跟 3 4 作为另一个，然后使用 when 到运行这两个承诺序列同时相互关联，但仍然享受这些序列中的连续行为。例如：

let firstTwo = promiseOne().then { something1 in
    self.promiseTwo(something1)
}

let secondTwo = promiseThree().then { something2 in
    self.promiseFour(something2)
}

when(fulfilled: [firstTwo, secondTwo]).then { results in
    os_log("all done: %@", results)
}.catch { error in
    os_log("some error: %@", error.localizedDescription)
}

在这种情况下，您可能会试图使问题保持相当笼统，这可能会使您更难看出如何在您的案例中应用此答案。因此，如果您遇到困难，您可能希望更具体地了解这四个 promise 正在做什么以及它们相互传递什么（因为这种将结果从一个传递到另一个是 promises 的优雅特征之一）。

如何确保 'start' 一起完成的两个异步任务在另一个运行之前完成？

How to ensure two asynchronous tasks that 'start' together are completed before running another?

asynchronous

swift

promisekit

片段

完整代码

输出

如何确保 'start' 一起完成的两个异步任务在另一个 运行 之前完成？

How to ensure two asynchronous tasks that 'start' together are completed before running another?

asynchronous

swift

promisekit

片段

完整代码

输出

如何确保 'start' 一起完成的两个异步任务在另一个运行之前完成？