背景

我正在实现搜索。每个搜索查询都会产生一个 DispatchWorkItem，然后排队等待执行。由于用户触发新搜索的速度比完成前一个搜索的速度快，因此我想在收到新搜索后立即取消前一个搜索。

这是我当前的设置:

var currentSearchJob: DispatchWorkItem?
let searchJobQueue = DispatchQueue(label: QUEUE_KEY)

func updateSearchResults(for searchController: UISearchController) {
    let queryString = searchController.searchBar.text?.lowercased() ?? ""

    // if there is already an (older) search job running, cancel it
    currentSearchJob?.cancel()

    // create a new search job
    currentSearchJob = DispatchWorkItem() {
        self.filter(queryString: queryString)
    }

    // start the new job
    searchJobQueue.async(execute: currentSearchJob!)
}

问题

我知道 dispatchWorkItem.cancel() 不会立即终止正在运行的任务。相反，我需要手动检查 dispatchWorkItem.isCancelled。但是在这种情况下，如何获得正确的 dispatchWorkItem 对象？

如果我只设置一次 currentSearchJob，我可以简单地访问该属性，就像 done in this case .但是，这在这里不适用，因为该属性将在 filter() 方法完成之前被覆盖。 我如何知道哪个实例实际运行了我要在其中检查 dispatchWorkItem.isCancelled 的代码？

理想情况下，我想提供新创建的 DispatchWorkItem 作为 filter() 方法的附加参数。但这是不可能的，因为我会得到一个 Variable used within its own initial value 错误。

我是 Swift 的新手，所以我希望我只是遗漏了一些东西。非常感谢任何帮助!

最佳答案

诀窍是如何让已分派(dispatch)的任务检查它是否已被取消。我实际上建议考虑 OperationQueue方法，而不是直接使用调度队列。

至少有两种方法:

• 最优雅的，恕我直言，就是子类化 Operation ，在 init 方法中传递你想要的任何东西，并在 main 中执行工作方法:

   class SearchOperation: Operation {
       private var queryString: String
  
       init(queryString: String) { 
           self.queryString = queryString
           super.init()
       }
  
       override func main() {
           // do something synchronous, periodically checking `isCancelled`
           // e.g., for illustrative purposes
  
           print("starting \(queryString)")
           for i in 0 ... 10 {
               if isCancelled { print("canceled \(queryString)"); return }
               print("  \(queryString): \(i)")
               heavyWork()
           }
           print("finished \(queryString)")
       }
  
       func heavyWork() {
           Thread.sleep(forTimeInterval: 0.5)
       }
   }
  

  因为它在 Operation 中子类，isCancelled隐式引用自身而不是一些ivar，避免对其检查的内容产生任何混淆。而您的“开始新查询”代码可以只说“取消相关操作队列中当前的任何内容，并将新操作添加到该队列”:

   private var searchQueue: OperationQueue = {
       let queue = OperationQueue()
       // queue.maxConcurrentOperationCount = 1  // make it serial if you want
       queue.name = Bundle.main.bundleIdentifier! + ".backgroundQueue"
       return queue
   }()
  
   func performSearch(for queryString: String) {
       searchQueue.cancelAllOperations()
       let operation = SearchOperation(queryString: queryString)
       searchQueue.addOperation(operation)
   }
  

  我推荐这种方法，因为您最终会得到一个小的内聚对象，即操作，它本着单一职责原则的精神很好地封装了您想要完成的工作 block 。

• 虽然以下不太优雅，但从技术上讲，您还可以使用基于 block 的 BlockOperation，但您可以将操作的创建和添加关闭操作。使用这种技术，您实际上可以将对该操作的引用传递给它自己的闭包:

   private weak var lastOperation: Operation?
  
   func performSearch(for queryString: String) {
       lastOperation?.cancel()
  
       let operation = BlockOperation()
       operation.addExecutionBlock { [weak operation, weak self] in
           print("starting \(identifier)")
           for i in 0 ... 10 {
               if operation?.isCancelled ?? true { print("canceled \(identifier)"); return }
               print("  \(identifier): \(i)")
               self?.heavyWork()
           }
           print("finished \(identifier)")
       }
       searchQueue.addOperation(operation)
       lastOperation = operation
   }
  
   func heavyWork() {
       Thread.sleep(forTimeInterval: 0.5)
   }
  

  为了完整起见，我只提到这一点。我认为 Operation 子类方法通常是更好的设计。我将使用 BlockOperation 来处理一次性的事情，但一旦我想要更复杂的取消逻辑，我认为 Operation 子类方法更好。

我还应该提到，除了更优雅的取消功能之外，Operation 对象还提供各种其他复杂的功能(例如，异步管理本身是异步的任务队列；限制并发性等)。这都超出了这个问题的范围。

关于ios - 如何获取多个 DispatchWorkItems 的取消状态，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/53762258/