如何在for循环中暂停调度队列？

Question

我有播放和暂停按钮。当我按下播放按钮时，我想在循环中播放异步对话。我使用调度组在 for 循环内等待异步方法。但我无法实现暂停。

startStopButton.rx.tap.bind {
    if self.isPaused {
        self.isPaused = false
        dispatchGroup.suspend()
        dispatchQueue.suspend()
    } else {
        self.isPaused = true
        self.dispatchQueue.async {
            for i in 0..<self.textBlocks.count {
                self.dispatchGroup.enter()
                self.startTalking(string: self.textBlocks[i]) { isFinished in
                    self.dispatchGroup.leave()
                }
                self.dispatchGroup.wait()
            }
        }
    }
}.disposed(by: disposeBag)

我尝试使用 operationqueue 但仍然无法正常工作。还在继续说话。

startStopButton.rx.tap.bind {
    if self.isPaused {
        self.isPaused = false
        self.talkingQueue.isSuspended = true
        self.talkingQueue.cancelAllOperations()
    } else {
        self.isPaused = true
        self.talkingQueue.addOperation {
            for i in 0..<self.textBlocks.count {
                self.dispatchGroup.enter()
                self.startTalking(string: self.textBlocks[i]) { isFinished in
                    self.dispatchGroup.leave()
                }
                self.dispatchGroup.wait()
            }
        }
    }
}.disposed(by: disposeBag)

有什么建议吗？

Answer 1

几点观察：

暂停群组没有任何作用。您暂停队列，而不是群组。
挂起队列会阻止新项目从该队列开始，但不会挂起该队列上已经运行的任何内容。因此，如果您已将所有 textBlock 调用添加到单个分派的工作项中，那么一旦启动，它就不会挂起。

因此，与其将所有这些文本块作为单个任务分派到队列中，不如单独提交它们（当然，假设您的队列是串行的）。因此，例如，假设您有一个 DispatchQueue:
```
let queue = DispatchQueue(label: "...")
```
然后，要对任务进行排队，将 async 调用放在循环中 for 中，因此每个文本块都是您的单独项目队列：
```
for textBlock in textBlocks {
    queue.async { [weak self] in
        guard let self = self else { return }

        let semaphore = DispatchSemaphore(value: 0)

        self.startTalking(string: textBlock) {
            semaphore.signal()
        }
        semaphore.wait()
    }
}
```
仅供参考，虽然调度组有效，但信号量（非常适合协调单个 signal 和 wait）在这里可能是更合乎逻辑的选择，而不是组（用于协调分派任务组）。

无论如何，当您挂起该队列时，该队列将阻止启动任何排队的内容（但会完成当前 textBlock）。
或者您可以使用异步 Operation，例如，创建您的队列：
```
let queue: OperationQueue = {
    let queue = OperationQueue()
    queue.name = "..."
    queue.maxConcurrentOperationCount = 1
    return queue
}()
```
然后，您再次将每个说出的单词排队，每个单词分别是该队列上的一个单独操作：
```
for textBlock in textBlocks {
    queue.addOperation(TalkingOperation(string: textBlock))
}
```
这当然假设您将谈话程序封装在一个操作中，例如：
```
class TalkingOperation: AsynchronousOperation {
    let string: String

    init(string: String) {
        self.string = string
    }

    override func main() {
        startTalking(string: string) {
            self.finish()
        }
    }

    func startTalking(string: String, completion: @escaping () -> Void) { ... }
}
```
我更喜欢这种方法，因为
- 我们没有阻塞任何线程；
- 谈话的逻辑很好地封装在 TalkingOperation 中，本着单一责任原则的精神；
- 您可以轻松暂停队列或取消所有操作。
顺便说一句，这是 AsynchronousOperation 的子class，它从 TalkingOperation class 中抽象出异步操作的复杂性。有很多方法可以做到这一点，但这里是 . FWIW, the idea is that you define an AsynchronousOperation subclass that does all the KVO necessary for asynchronous operations outlined in the documentation，然后您可以享受操作队列的好处，而不必使每个异步操作子 class 太复杂。

对于它的价值，如果你不需要挂起，但很高兴只是取消，另一种方法是将整个 for 循环作为单个工作项分派或操作，但检查操作是否已在 for 循环内取消：

所以，定义几个属性：

let queue = DispatchQueue(label: "...")
var item: DispatchWorkItem?

然后就可以开始任务了：

item = DispatchWorkItem { [weak self] in
    guard let textBlocks = self?.textBlocks else { return }

    for textBlock in textBlocks where self?.item?.isCancelled == false {
        let semaphore = DispatchSemaphore(value: 0)
        self?.startTalking(string: textBlock) {
            semaphore.signal()
        }
        semaphore.wait()
    }
    self?.item = nil
}

queue.async(execute: item!)

然后，当您想停止它时，只需调用 item?.cancel()。您也可以使用非异步 Operation 执行相同的模式。

如何在for循环中暂停调度队列？

How to suspend dispatch queue inside for loop?

nsoperationqueue

grand-central-dispatch

ios

swift