Swift 按顺序执行异步任务

Question

我需要在我的应用上执行一些异步网络任务。假设我需要从服务器获取 3 个资源，分别称为 A、B 和 C。假设在获取B 或C 之前，我必须先完成获取资源A。有时，我想先获取B，其他时候先获取C。

现在，我只有一个像这样的长链闭包：

func fetchA() {
  AFNetworking.get(completionHandler: {
    self.fetchB()
    self.fetchC()
  })
}

这暂时可行，但明显的限制是我已将执行顺序硬编码到 fetchA 的完成处理程序中。现在，假设我只想在fetchB 在完成处理程序中完成之后只使用fetchC，我将不得不为fetchB 更改我的实现...

基本上，我想知道是否有一些神奇的方法可以做类似的事情：

let orderedAsync = [fetchA, fetchB, fetchC]
orderedAsync.executeInOrder()

其中fetchA、fetchB 和fetchC 都是异步函数，但fetchB 在fetchA 完成之前不会执行等等。谢谢！

Answer 1

您可以将串行DispatchQueue 与DispatchGroup 混合使用，这将确保一次只运行一个执行块。

let serialQueue = DispatchQueue(label: "serialQueue")
let group = DispatchGroup()
group.enter()
serialQueue.async{  //call this whenever you need to add a new work item to your queue
    fetchA{
        //in the completion handler call
        group.leave()
    }
}
serialQueue.async{
    group.wait()
    group.enter()
    fetchB{
        //in the completion handler call
        group.leave()
    }
}
serialQueue.async{
    group.wait()
    group.enter()
    fetchC{
        group.leave()
    }
}

或者，如果您被允许使用第 3 方库，请使用 PromiseKit，它比 GCD 提供的任何东西都更容易处理，尤其是链接异步方法。请参阅official GitHub 页面了解更多信息。 您可以将带有完成处理程序的异步方法包装在 Promise 中，并将它们链接在一起，如下所示：

Promise.wrap(fetchA(completion:$0)).then{ valueA->Promise<typeOfValueB> in
    return Promise.wrap(fetchB(completion:$0)
}.then{ valueB in

}.catch{ error in
    //handle error
}

此外，所有错误都会通过您的 Promise 传播。

Answer 2

您可以结合使用 dispatchGroup 和 dispatchSemaphore 来依次执行异步代码块。

• 当所有任务完成时，DispatchGroup 会保持进出通知。
• 值为 1 的 DispatchSemaphore 将确保只执行一个任务块

示例 fetchA, fetchB, fetchC 是带有闭包的函数（完成处理程序）的代码

// Create DispatchQueue
private let dispatchQueue = DispatchQueue(label: "taskQueue", qos: .background)

//value 1 indicate only one task will be performed at once.
private let semaphore = DispatchSemaphore(value: 1)

func sync() -> Void {
    let group = DispatchGroup()

    group.enter()
    self.dispatchQueue.async {
        self.semaphore.wait()
        fetchA() { (modelResult) in
            // success or failure handler

            // semaphore signal to remove wait and execute next task
            self.semaphore.signal()
            group.leave()
        }
    }

    group.enter()
    self.dispatchQueue.async {
        self.semaphore.wait()
        fetchB() { (modelResult) in
            // success or failure handler

            // semaphore signal to remove wait and execute next task
            self.semaphore.signal()
            group.leave()
        }
    }

    group.enter()
    self.dispatchQueue.async {
        self.semaphore.wait()
        fetchC() { (modelResult) in
            // success or failure handler

            // semaphore signal to remove wait and execute next task
            self.semaphore.signal()
            group.leave()
        }
    }        

    group.notify(queue: .main) {

        // Perform any task once all the intermediate tasks (fetchA(), fetchB(), fetchC()) are completed. 
        // This block of code will be called once all the enter and leave statement counts are matched.

    }
}

Answer 3

不确定为什么其他答案会添加不必要的代码，您所描述的已经是串行队列的默认行为：

let fetchA = { print("a starting"); sleep(1); print("a done")}
let fetchB = { print("b starting"); sleep(1); print("b done")}
let fetchC = { print("c starting"); sleep(1); print("c done")}

let orderedAsync = [fetchA, fetchB, fetchC]
let queue = DispatchQueue(label: "fetchQueue")

for task in orderedAsync{
    queue.async(execute: task) //notice "async" here
}

print("all enqueued")
sleep(5)

"all enqueued" 将立即打印，每个任务将等待前一个任务完成后再开始。

仅供参考，如果您将 attributes: .concurrent 添加到您的 DispatchQueue 初始化中，则不能保证它们按顺序执行。但即便如此，当您希望事情按顺序执行时，您也可以使用.barrier 标志。

换句话说，这也可以满足您的要求：

let queue = DispatchQueue(label: "fetchQueue", attributes: .concurrent)

for task in orderedAsync{
    queue.async(flags: .barrier, execute: task)
}