ios - 如何保证OperationQueue中的操作一个接一个完成

Question

当执行相互依赖的操作时，OperationQueue 可用于确保它们以正确的顺序执行。但是，是否也可以保证操作一个接一个地完成？

假设一个方法是异步执行的，需要一些时间才能完成:

public func performOperation(_ number: Int, success: @escaping (Int) -> Void)->Void {
        DispatchQueue(label: "operations").async {
            print("Operation #\(number) starts")
            usleep(useconds_t(1000-number*200)) // Block thread for some time
            success(number)
        }
}

操作和依赖创建如下:

let operationQueue = OperationQueue.main
for operationNumber in 0..<4 { // Create operations as an example
    let operation = BlockOperation(block: {
        performOperation(operationNumber) { number in
            DispatchQueue.main.sync {
                print("Operation #\(number) finished")
            }
        }
    })
    operation.name = "Operation #\(operationNumber)"

    if operationNumber > 0 {
        operation.addDependency(operationQueue.operations.last!)
        // Print dependencies
        print("\(operation.name!) should finish after \(operation.dependencies.first!.name!)")
    }
    operationQueue.addOperation(operation)
}

输出如下:

Operation #1 should finish after Operation #0
Operation #2 should finish after Operation #1
Operation #3 should finish after Operation #2
Operation #0 starts
Operation #1 starts
Operation #2 starts
Operation #3 starts
Operation #0 finished
Operation #3 finished
Operation #2 finished
Operation #1 finished

这显然是不正确的。似乎 OperationQueue 只确保操作以正确的顺序开始(而不是一个接一个地完成)。尽管这可以使用 DispatchSemaphore 执行，但我想知道是否也可以使用 OperationQueue。

Answer 1

操作依赖于完成操作，而不是开始操作，因此系统的行为与此处记录的一样。问题是 DispatchQueue(label: "operations").async – 你的 performOperation 方法在你进入它之后立即退出异步调度序列打印……；睡着了……； success …，进入为每个 performOperation 调用创建的新调度队列。然后，打印/ sleep /成功回调序列在由 Grand Central Dispatch 管理的工作线程池的不同线程上执行。

我想你在这里可能会感到困惑的是认为重复声明 DispatchQueue(label: "operations") 会得到相同的串行调度队列实例——事实并非如此，你实际上每次调用时创建一个新的串行队列。

顺便说一句，也没有理由在您的 performOperation 中创建或分派(dispatch)到串行分派(dispatch)队列，因为 BlockOperation 已经实现，因此该 block 可以并发执行在支持 OperationQueue ( the concurrency is also possible to limit ) 的 GCD 调度队列上。在你的情况下我会做的是用 OperationQueue() 构造一个新的 OperationQueue (而不是使用 OperationQueue.main 在主队列上调度工作)，然后异步调度你的成功回调到主队列。

这个稍微修改过的示例向您展示了操作执行确实遵循依赖关系(我没有实现上述与 OperationQueue 相关的建议，它可以说与您提出的问题无关):

public func performOperation(_ number: Int, success: @escaping (Int) -> Void)->Void {
    print("Operation #\(number) starts")
    usleep(useconds_t(1000-(number*50))) // Block thread for some time
    success(number)
}

… 

let operationQueue = OperationQueue.main
for operationNumber in 0..<8 { // Create operations as an example
    let operation = BlockOperation(block: {
        self.performOperation(operationNumber) { number in
            print("Operation #\(number) finished")
        }
    })
    operation.name = "Operation #\(operationNumber)"

    if operationNumber > 0 {
        operation.addDependency(operationQueue.operations.last!)
        // Print dependencies
        print("\(operation.name!) should finish after \(operation.dependencies.first!.name!)")
    }
    operationQueue.addOperation(operation)
}

这将输出...

Operation #1 should finish after Operation #0
Operation #2 should finish after Operation #1
Operation #3 should finish after Operation #2
Operation #4 should finish after Operation #3
Operation #5 should finish after Operation #4
Operation #6 should finish after Operation #5
Operation #7 should finish after Operation #6
Operation #0 starts
Operation #0 finished
Operation #1 starts
Operation #1 finished
Operation #2 starts
Operation #2 finished
Operation #3 starts
Operation #3 finished
Operation #4 starts
Operation #4 finished
Operation #5 starts
Operation #5 finished
Operation #6 starts
Operation #6 finished
Operation #7 starts
Operation #7 finished