无法取消执行中的OperationQueue swift操作

Question

我正在进行一些耗时的计算，以创建图表数据在后台线程上。

我最初使用GCD，但每次用户通过点击按钮过滤图表数据时，图表数据都需要重新计算。如果用户快速点击图表数据过滤按钮（高级用户），那么每个GCD调度异步完成后，图表就会循环绘制。

我意识到我无法使用GCD取消线程，因此我尝试实现一个OperationQueue。

我在添加新操作到队列之前调用cancelAllOperations()。

队列中的操作有时会出现异常，有时看起来它们被取消了，有时看起来已经完成的不是最近放入队列的操作。

我还遇到了取消正在执行操作的问题，因为当我在操作完成块中检查操作的.isCancelled属性时，它从未为真。

我真正想要的是，如果图表数据计算当前正在后台线程中进行，并且用户点击另一个过滤按钮并在后台线程上启动另一个图表计算，则先前的图表后台线程计算将被终止并“替换”为最近添加的操作。

这可能吗？下面是一些代码：

func setHistoricalChart() -> Void {
    self.lineChartView.clear()
    self.lineChartView.noDataText = "Calculating Historical Totals, Please Wait..."

    self.historicalOperationsQueue.qualityOfService = .utility
    self.historicalOperationsQueue.maxConcurrentOperationCount = 1
    self.historicalOperationsQueue.name = "historical operations queue"

    let historicalOperation = Operation()
    historicalOperation.completionBlock = { [weak self] in
        //dictionary of feeds, array of data for each feed
        var valuesByFeed = [String:[String]?]()
        var dates = [String:[String]?]()
        var chartDataSets = [IChartDataSet]()

        //get data and values from DataMOs in the activeFeeds
        if (self?.activeFeeds.count)! > 0 {
            //check if operation is cancelled
            if historicalOperation.isCancelled {
                return
            }
            for (key, feed) in (self?.activeFeeds)! {
                dates[key] = feed?.datas?.flatMap({ Utils.formatUTCDateString(utcDateString: ($0 as! DataMO).utcDateString) })
                valuesByFeed[key] = feed?.datas?
                    .sorted(by: { (($0 as! DataMO).utcDateString)! < (($1 as! DataMO).utcDateString)! })
                    .flatMap({ ($0 as! DataMO).value })
            }

            //Create Chart Data
            for (key, valuesArray) in valuesByFeed {
                var dataEntries = [ChartDataEntry]()
                for (index, value) in (valuesArray?.enumerated())! {
                    let dataEntry = ChartDataEntry(x: Double(index), y: Double(value)!)
                    dataEntries.append(dataEntry)
                }
                let singleChartDataSet = LineChartDataSet(values: dataEntries, label: key)
                singleChartDataSet.drawCirclesEnabled = false
                switch key {
                case "Solar":
                    singleChartDataSet.setColors(UIColor(red: 230/255, green: 168/255, blue: 46/255, alpha: 1))
                    singleChartDataSet.drawFilledEnabled = true
                    singleChartDataSet.fillColor = UIColor(red: 230/255, green: 168/255, blue: 46/255, alpha: 0.8)
                    break
                case "Wind":
                    singleChartDataSet.setColors(UIColor(red: 73/255, green: 144/255, blue: 226/255, alpha: 1))
                    singleChartDataSet.drawFilledEnabled = true
                    singleChartDataSet.fillColor = UIColor(red: 73/255, green: 144/255, blue: 226/255, alpha: 0.8)
                    break
                case "Battery":
                    singleChartDataSet.setColors(UIColor(red: 126/255, green: 211/255, blue: 33/255, alpha: 1))
                    singleChartDataSet.drawFilledEnabled = true
                    singleChartDataSet.fillColor = UIColor(red: 126/255, green: 211/255, blue: 33/255, alpha: 0.8)
                    break
                case "Gen":
                    singleChartDataSet.setColors(UIColor(red: 208/255, green: 1/255, blue: 27/255, alpha: 1))
                    singleChartDataSet.drawFilledEnabled = true
                    singleChartDataSet.fillColor = UIColor(red: 208/255, green: 1/255, blue: 27/255, alpha: 0.8)
                    break
                case "Demand":
                    singleChartDataSet.setColors(UIColor(red: 128/255, green: 133/255, blue: 233/255, alpha: 1))
                    singleChartDataSet.drawFilledEnabled = true
                    singleChartDataSet.fillColor = UIColor(red: 128/255, green: 133/255, blue: 233/255, alpha: 0.8)
                    break
                case "Prod":
                    singleChartDataSet.setColors(UIColor(red: 241/255, green: 92/255, blue: 128/255, alpha: 1))
                    singleChartDataSet.drawFilledEnabled = true
                    singleChartDataSet.fillColor = UIColor(red: 241/255, green: 92/255, blue: 128/255, alpha: 0.8)
                    break
                default:
                    break
                }
                chartDataSets.append(singleChartDataSet)
            }
        }

        //check if operation is cancelled
        if historicalOperation.isCancelled {
            return
        }

        //set chart data
        let chartData = LineChartData(dataSets: chartDataSets)

        //update UI on MainThread
        OperationQueue.main.addOperation({
            if (self?.activeFeeds.count)! > 0 {
                self?.lineChartView.data = chartData
            } else {
                self?.lineChartView.clear()
                self?.lineChartView.noDataText = "No Feeds To Show"
            }
        })
    }
    historicalOperationsQueue.cancelAllOperations()
    historicalOperationsQueue.addOperation(historicalOperation)
}

- Derek Hannah

---

取消操作容易受到竞态条件的影响，这是无法避免的。在更新GUI或任何非本地状态变量之前，将所有耗时调用安排在操作开始时可能对您有益。您的操作中最耗时的功能是什么？ - Code Different

我还推荐来自2015年WWDC的高级NSOperations。取消操作在5:00左右进行讨论。 - Code Different

当更新正在进行时禁用刷新按钮更有意义，不是吗？ - Code Different

图表数据的创建有时需要几秒钟时间，即使在后台线程上也是如此，在进行繁重的计算。 - Derek Hannah

就我的看法，我不推荐使用高级NSOperations。最好的情况下，它对这种场景来说是可怕的过度设计。最糟糕的情况下，我认为这是苹果更令人尴尬、过度工程化的代码之一，而且它根本没有解决上述问题。但所有这些都无关紧要，因为上述代码的问题在于取消逻辑中存在一个简单的错误，这使得正在运行的操作无法被取消。 - Rob

Answer 1

我意识到我无法使用GCD取消线程...

只是顺带一提，这并不完全正确。您可以取消分派到GCD队列的DispatchWorkItem项目：

var item: DispatchWorkItem!
item = DispatchWorkItem {
    ...

    while notYetDone() {
        if item.isCancelled {
            os_log("canceled")
            return
        }

        ...
    }

    os_log("finished")
}

let queue = DispatchQueue(label: Bundle.main.bundleIdentifier! + ".customQueue")

queue.async(execute: item)

// just to prove it's cancelable, let's cancel it one second later

DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
    os_log("canceling")
    item.cancel()
}

诚然，您必须取消单个DispatchWorkItem实例，但它确实起作用。

...所以我开始尝试实现一个OperationQueue

不幸的是，这并没有被正确实现。简而言之，问题中的代码创建了一个什么也不做的操作本身，但其所有计算密集型代码都在其完成处理程序中。但是，这个完成处理程序只有在操作“已完成”后才被调用。已经完成操作（即那些已经运行完成处理程序的操作）无法取消。因此，操作将忽略尝试取消这些正在进行的、耗时的完成处理程序块的尝试。

相反，创建一个块操作，并将逻辑作为“执行块”添加，而不是作为完成处理程序。然后取消操作按预期工作：

let operation = BlockOperation()
operation.addExecutionBlock {
    ...

    while notYetDone() {
        if operation.isCancelled {
            os_log("canceled")
            return
        }

        ...
    }

    os_log("finished")
}

let queue = OperationQueue()
queue.maxConcurrentOperationCount = 1

queue.addOperation(operation)

// just to prove it's cancelable, let's cancel it

DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
    os_log("canceling")
    operation.cancel()
}

或者，更好的方法是创建一个Operation子类来完成这项工作。使用Operation和OperationQueue的一个优点是可以将复杂的操作代码从视图控制器代码中分离出来。

例如：

class ChartOperation: Operation {

    var feeds: [Feed]
    private var chartOperationCompletion: (([IChartDataSet]?) -> Void)?

    init(feeds: [Feed], completion: (([IChartDataSet]?) -> Void)? = nil) {
        self.feeds = feeds
        self.chartOperationCompletion = completion
        super.init()
    }

    override func main() {
        let results = [IChartDataSet]()

        while notYetDone() {
            if isCancelled {
                OperationQueue.main.addOperation {
                    self.chartOperationCompletion?(nil)
                    self.chartOperationCompletion = nil
                }
                return
            }

            ...
        }

        OperationQueue.main.addOperation {
            self.chartOperationCompletion?(results)
            self.chartOperationCompletion = nil
        }
    }

}

我不知道你的activeFeeds是什么，所以我将其声明为一个Feed数组，但请根据需要进行调整。不过这说明了同步操作的思路：只需子类化Operation并添加一个main方法即可。如果您想将数据传递给操作，请将其作为参数添加到init方法中。如果您想将数据传回，请添加一个闭包参数，在操作完成时将调用该参数。注意，我更喜欢这种方式而不是依赖于内置的completionHandler，因为它无法像上面自定义的完成处理程序那样提供传递给闭包的参数的机会。

总之，您的视图控制器可以执行以下操作：

let operation = ChartOperation(feeds: activeFeeds) { results in
    // update UI here
}

queue.addOperation(operation)

就像上面的例子一样，这也是可取消的。

---

顺便说一下，虽然我展示了如何确保操作可取消，但您可能还想确保在各种循环中检查isCancelled（或者可能只在最深层嵌套的for 循环中检查）。目前，您在进程的早期检查了isCancelled，如果您稍后不检查它，则会忽略随后的取消。 调度和操作队列不执行抢占式取消，因此必须在希望识别取消的任何点插入isCancelled检查。

- Rob