我想在事件发生后的 10 秒内运行一段代码，但我希望能够取消它，这样如果在这 10 秒之前发生了某些事情，则代码在 10 秒过去后将不会运行。
我一直在用这个，但是不能取消：
static func delay(delay:Double, closure:()->()) {
dispatch_after(
dispatch_time(
DISPATCH_TIME_NOW,
Int64(delay * Double(NSEC_PER_SEC))
),
dispatch_get_main_queue(), closure
)
}
我怎样才能做到这一点？
【问题讨论】：
你需要这样做：
class WorkItem {
private var pendingRequestWorkItem: DispatchWorkItem?
func perform(after: TimeInterval, _ block: @escaping VoidBlock) {
// Cancel the current pending item
pendingRequestWorkItem?.cancel()
// Wrap the request in a work item
let requestWorkItem = DispatchWorkItem(block: block)
pendingRequestWorkItem = requestWorkItem
DispatchQueue.main.asyncAfter(deadline: .now() + after, execute:
requestWorkItem)
}
}
// Use
lazy var workItem = WorkItem()
private func onMapIdle() {
workItem.perform(after: 1.0) {
self.handlePOIListingSearch()
}
}
参考文献
【讨论】：
出于某种原因，NSObject.cancelPreviousPerformRequests(withTarget: self) 不适合我。我想到的一个解决方法是提出我允许的最大循环数，然后使用该 Int 来控制该函数是否被调用。
然后我可以在我的代码中的其他任何地方设置 currentLoop 值，它会停止循环。
//loopMax = 200
var currentLoop = 0
func loop() {
if currentLoop == 200 {
//do nothing.
} else {
//perform loop.
//keep track of current loop count.
self.currentLoop = self.currentLoop + 1
let deadline = DispatchTime.now() + .seconds(1)
DispatchQueue.main.asyncAfter(deadline: deadline) {
//enter custom loop parameters
print("i looped")
self.loop()
}
}
然后你可以在代码的其他地方
func stopLooping() {
currentLoop = 199
//setting it to 199 allows for one last loop to happen. You can adjust based on the amount of loops you want to be able to do before it just stops. For instance you can set currentLoop to 195 and then implement a fade animation while loop is still happening a bit.
}
它实际上非常动态。例如，您可以查看 currentLoop == 123456789，它会无限运行（几乎），直到您在代码中的其他位置将其设置为该值。或者，即使您的需求不像我的那样基于时间，您也可以将其设置为 String() 或 Bool()。
【讨论】：
Swift 3.0 更新
设置执行选择器
perform(#selector(foo), with: nil, afterDelay: 2)
foo 方法将在 2 秒后调用
func foo()
{
//do something
}
取消挂起的方法调用
NSObject.cancelPreviousPerformRequests(withTarget: self)
【讨论】：
cancelPreviousPerformRequests 对我来说效果很好。
cancelPreviousPerformRequests(withTarget:selector:object:)，我们可以指定我们要取消的执行请求。并记住使用相同的线程，即主线程。
试试这个（Swift 2.x，见下面大卫对 Swift 3 的回答）：
typealias dispatch_cancelable_closure = (cancel : Bool) -> ()
func delay(time:NSTimeInterval, closure:()->()) -> dispatch_cancelable_closure? {
func dispatch_later(clsr:()->()) {
dispatch_after(
dispatch_time(
DISPATCH_TIME_NOW,
Int64(time * Double(NSEC_PER_SEC))
),
dispatch_get_main_queue(), clsr)
}
var closure:dispatch_block_t? = closure
var cancelableClosure:dispatch_cancelable_closure?
let delayedClosure:dispatch_cancelable_closure = { cancel in
if let clsr = closure {
if (cancel == false) {
dispatch_async(dispatch_get_main_queue(), clsr);
}
}
closure = nil
cancelableClosure = nil
}
cancelableClosure = delayedClosure
dispatch_later {
if let delayedClosure = cancelableClosure {
delayedClosure(cancel: false)
}
}
return cancelableClosure;
}
func cancel_delay(closure:dispatch_cancelable_closure?) {
if closure != nil {
closure!(cancel: true)
}
}
// usage
let retVal = delay(2.0) {
println("Later")
}
delay(1.0) {
cancel_delay(retVal)
}
来自 Waam 的评论：dispatch_after - GCD in swift?
【讨论】：
asyncAfter:execute: 有时不遵守最后期限：clouse 的执行时间比预期的要晚。 @DavidLawson 的回答虽然效果很好。
Swift 3 有 DispatchWorkItem:
let task = DispatchWorkItem { print("do something") }
// execute task in 2 seconds
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 2, execute: task)
// optional: cancel task
task.cancel()
【讨论】：
NSObject 函数为您处理它，因此没有簿记。 （当然，如果你说的是纯 Swift，那么NSObject 方式不是一个选项。）
我在一些项目中使用@sas 的方法，不知何故这不再起作用，也许在 Swift 2.1.1 之后发生了一些变化。值拷贝而不是指针？
对我来说最简单的解决方法是：
var canceled = false
delay(0.25) {
if !canceled {
doSomething()
}
}
【讨论】：
这应该可行：
var doIt = true
var timer = NSTimer.scheduledTimerWithTimeInterval(10, target: self, selector: Selector("doSomething"), userInfo: nil, repeats: false)
//you have now 10 seconds to change the doIt variable to false, to not run THE CODE
func doSomething()
{
if(doIt)
{
//THE CODE
}
timer.invalidate()
}
【讨论】：