【问题标题】：dispatch_after - GCD in Swift?dispatch_after - Swift 中的 GCD？
【发布时间】：2014-07-24 22:23:02
【问题描述】：

我浏览了 Apple 的 iBook，但找不到它的任何定义：

谁能解释一下dispatch_after的结构？

dispatch_after(<#when: dispatch_time_t#>, <#queue: dispatch_queue_t?#>, <#block: dispatch_block_t?#>)

【问题讨论】：

Apple 在 2018 年未出版这本书。Latest archive I could find is from December 2017。指向 iBook 的旧链接现在只需重定向到 developer.apple.com/documentation/swift。

标签： objective-c swift grand-central-dispatch

【解决方案1】：

保留`current queue`!

除了这个问题的好答案外，您还可以考虑保留当前队列以防止不必要的主队列操作（例如，当您尝试延迟某些异步操作时）。

func after(_ delay: TimeInterval,
           perform block: @escaping ()->(),
           on queue: DispatchQueue = OperationQueue.current?.underlyingQueue ?? .main) { // So this `queue` preserves the current queue and defaulted to the `main`. Also the caller can pass in the desired queue explicitly
    queue.asyncAfter(deadline: .now() + delay, execute: block)
}

用法：

after(3) {
    // will be executed on the caller's queue
    print(Date())
}

【讨论】：

【解决方案2】：

要在延迟后执行函数或代码，请使用下一个方法

DispatchQueue.main.asyncAfter(deadline: .now() + 'secondsOfDelay') {
        your code here...
    }

示例 - 在此示例中，函数 getShowMovies 将在 1 秒后执行

DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
        self.getShowMovies()
    }

【讨论】：

【解决方案3】：

在 Swift 5 中，在下面使用：

 DispatchQueue.main.asyncAfter(deadline: .now() + 0.2, execute: closure) 

// time gap, specify unit is second
DispatchQueue.main.asyncAfter(deadline: .now() + .seconds(2)) {
            Singleton.shared().printDate()
        }
// default time gap is second, you can reduce it
    DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
          // just do it!
    }

【讨论】：

【解决方案4】：

我经常使用dispatch_after，以至于我编写了一个顶级实用函数来简化语法：

func delay(delay:Double, closure:()->()) {
    dispatch_after(
        dispatch_time(
            DISPATCH_TIME_NOW,
            Int64(delay * Double(NSEC_PER_SEC))
        ),
        dispatch_get_main_queue(), closure)
}

现在你可以这样说话了：

delay(0.4) {
    // do stuff
}

哇，一种可以改进语言的语言。还有什么更好的？

Swift 3、Xcode 8 Seed 6 的更新

现在他们已经改进了调用语法，似乎几乎不值得打扰：

func delay(_ delay:Double, closure:@escaping ()->()) {
    let when = DispatchTime.now() + delay
    DispatchQueue.main.asyncAfter(deadline: when, execute: closure)
}

【讨论】：

我只需要快捷方式来计算延迟，结果是：func delayInSec(delay: Double) -> dispatch_time_t { return dispatch_time(DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC))) }
@agf119105 如果闭包中只有一行代码，请添加另一行代码（例如return）。
@GastonM 无关紧要。传递一个函数本身没有内存管理问题。
“一种可以改进语言的语言”。我不明白定义一个全局函数是如何改进语言的，或者为什么这在 C 中是不可行的。也许如果你重载一个运算符；）1.0 ~~ { code...}
不质疑您答案的正确性——但 “我经常使用 dispatch_after” 不是一种代码味道，最好由 not 提供便利功能？

【解决方案5】：

这是 Swift 中 asyncAfter 的同步版本：

let deadline = DispatchTime.now() + .seconds(3)
let semaphore = DispatchSemaphore.init(value: 0)
DispatchQueue.global().asyncAfter(deadline: deadline) {
    dispatchPrecondition(condition: .onQueue(DispatchQueue.global()))
    semaphore.signal()
}

semaphore.wait()

连同异步一个：

let deadline = DispatchTime.now() + .seconds(3)
DispatchQueue.main.asyncAfter(deadline: deadline) {
    dispatchPrecondition(condition: .onQueue(DispatchQueue.global()))
}

【讨论】：

【解决方案6】：

Swift 3+

这在 Swift 3+ 中非常简单和优雅：

DispatchQueue.main.asyncAfter(deadline: .now() + 4.5) {
    // ...
}

旧答案：

为了扩展 Cezary 的答案，它将在 1 纳秒后执行，我必须在 4 秒半后执行以下操作。

let delay = 4.5 * Double(NSEC_PER_SEC)
let time = dispatch_time(DISPATCH_TIME_NOW, Int64(delay))
dispatch_after(time, dispatch_get_main_queue(), block)

编辑：我发现我的原始代码有点错误。如果您不将 NSEC_PER_SEC 转换为 Double，则隐式类型会导致编译错误。

如果有人能提出更优化的解决方案，我很乐意听到。

【讨论】：

我收到了一个编译器错误，它显示了一个带有dispatch_get_current_queue() 的已弃用 API。我改用dispatch_get_main_queue()。
@DavidL - 谢谢，dispatch_get_main_queue() 绝对是您应该使用的。会更新。
我在 swift 3 的操场上试过这个，但它不起作用
@GAlexander 为我工作。您是否允许 Playground 无限期执行？
嗯，不，我让 run 运行了几个小时，仍然没有打印出来。这是我用的。 "import Dispatch import Darwin import CoreGraphics 'DispatchQueue.main.asyncAfter(deadline: .now() + 4.5) { print(" got here") } "

【解决方案7】：

Swift 3.0 & Swift 4.0 & Swift 5.0 中最简单的解决方案

func delayWithSeconds(_ seconds: Double, completion: @escaping () -> ()) {
    DispatchQueue.main.asyncAfter(deadline: .now() + seconds) { 
        completion()
    }
}

用法

delayWithSeconds(1) {
   //Do something
}

【讨论】：

【解决方案8】：

1) 将此方法添加为 UIViewController Extension 的一部分。

extension UIViewController{
func runAfterDelay(delay: NSTimeInterval, block: dispatch_block_t) {
        let time = dispatch_time(DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC)))
        dispatch_after(time, dispatch_get_main_queue(), block)
    }
}

在VC上调用这个方法：

    self.runAfterDelay(5.0, block: {
     //Add code to this block
        print("run After Delay Success")
    })

2)

performSelector("yourMethod Name", withObject: nil, afterDelay: 1)

3)

override func viewWillAppear(animated: Bool) {

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 2), dispatch_get_main_queue(), { () -> () in
    //Code Here
})

//压缩表格

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 2), dispatch_get_main_queue()) {
    //Code here
 }
}

【讨论】：

【解决方案9】：

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(10 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    // ...
});

dispatch_after(_:_:_:) 函数接受三个参数：

延迟
调度队列
块或闭包

dispatch_after(_:_:_:) 函数调用调度队列上的块或闭包，在给定延迟后传递给函数。请注意，延迟是使用dispatch_time(_:_:) 函数创建的。记住这一点，因为我们也在 Swift 中使用了这个函数。

我建议阅读教程Raywenderlich Dispatch tutorial

【讨论】：

【解决方案10】：

在 Swift 4

使用这个sn-p：

    let delayInSec = 1.0
    DispatchQueue.main.asyncAfter(deadline: .now() + delayInSec) {
       // code here
       print("It works")
    }

【讨论】：

这已经在其他答案中（例如，brindy 的或 Rahul 的）...相同的语法...

【解决方案11】：

对于多个功能，请使用此功能。这对于将动画或 Activity 加载器用于静态功能或任何 UI 更新非常有帮助。

DispatchQueue.main.asyncAfter(deadline: .now() + 0.9) {
            // Call your function 1
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                // Call your function 2
            }
        }

例如 - 在 tableView 重新加载之前使用动画。或动画后的任何其他 UI 更新。

*// Start your amination* 
self.startAnimation()
DispatchQueue.main.asyncAfter(deadline: .now() + 0.9) {
                *// The animation will execute depending on the delay time*
                self.stopAnimation()
                DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                    *// Now update your view*
                     self.fetchData()
                     self.updateUI()
                }
            }

【讨论】：

【解决方案12】：

在 swift 中使用 asyncAfter 延迟 GCD 调用

let delayQueue = DispatchQueue(label: "com.theappmaker.in", qos: .userInitiated)
let additionalTime: DispatchTimeInterval = .seconds(2)

我们可以延迟**微秒、毫秒、纳秒

delayQueue.asyncAfter(deadline: .now() + 0.60) {
    print(Date())
}

delayQueue.asyncAfter(deadline: .now() + additionalTime) {
    print(Date())
}

【讨论】：

【解决方案13】：

Swift 3 和 4：

您可以在 DispatchQueue 上创建一个扩展，并添加在内部使用 DispatchQueue asyncAfter 函数的函数延迟

extension DispatchQueue {
    static func delay(_ delay: DispatchTimeInterval, closure: @escaping () -> ()) {
        let timeInterval = DispatchTime.now() + delay
        DispatchQueue.main.asyncAfter(deadline: timeInterval, execute: closure)
    }
}

使用：

DispatchQueue.delay(.seconds(1)) {
    print("This is after delay")
}

【讨论】：

【解决方案14】：

Swift 4 有一个非常短的方法：

Timer.scheduledTimer(withTimeInterval: 2, repeats: false) { (timer) in
    // Your stuff here
    print("hello")
}

【讨论】：

【解决方案15】：

我总是更喜欢使用扩展而不是免费功能。

斯威夫特 4

public extension DispatchQueue {

  private class func delay(delay: TimeInterval, closure: @escaping () -> Void) {
    let when = DispatchTime.now() + delay
    DispatchQueue.main.asyncAfter(deadline: when, execute: closure)
  }

  class func performAction(after seconds: TimeInterval, callBack: @escaping (() -> Void) ) {
    DispatchQueue.delay(delay: seconds) {
      callBack()
    }
  }

}

如下使用。

DispatchQueue.performAction(after: 0.3) {
  // Code Here
}

【讨论】：

【解决方案16】：

现在不仅仅是 Swift 中 Grand Central Dispatch (GCD) 中异步调度的语法糖。

添加 Podfile

pod 'AsyncSwift'

那么，你就可以这样使用了。

let seconds = 3.0
Async.main(after: seconds) {
print("Is called after 3 seconds")
}.background(after: 6.0) {
print("At least 3.0 seconds after previous block, and 6.0 after Async code is called")
}

【讨论】：

Apple 用几行代码就为我们提供了使用 GCD 所需的一切。为什么要打扰 Pod、工作区等？只需阅读有关 @escaping 和捕获的文档。够了。

【解决方案17】：

这对我有用。

斯威夫特 3：

let time1 = 8.23
let time2 = 3.42

// Delay 2 seconds

DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
    print("Sum of times: \(time1 + time2)")
}

目标-C：

CGFloat time1 = 3.49;
CGFloat time2 = 8.13;

// Delay 2 seconds

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    CGFloat newTime = time1 + time2;
    NSLog(@"New time: %f", newTime);
});

【讨论】：

【解决方案18】：

Apple 有一个 dispatch_after sn-p 用于 Objective-C：

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(<#delayInSeconds#> * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    <#code to be executed after a specified delay#>
});

这是移植到 Swift 3 的相同 sn-p：

DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + <#delayInSeconds#>) {
  <#code to be executed after a specified delay#>
}

【讨论】：

【解决方案19】：

另一个延迟您的代码的助手，它是100% Swift 使用，并且可以选择允许选择不同的线程从以下位置运行您的延迟代码：

public func delay(bySeconds seconds: Double, dispatchLevel: DispatchLevel = .main, closure: @escaping () -> Void) {
    let dispatchTime = DispatchTime.now() + seconds
    dispatchLevel.dispatchQueue.asyncAfter(deadline: dispatchTime, execute: closure)
}

public enum DispatchLevel {
    case main, userInteractive, userInitiated, utility, background
    var dispatchQueue: DispatchQueue {
        switch self {
        case .main:                 return DispatchQueue.main
        case .userInteractive:      return DispatchQueue.global(qos: .userInteractive)
        case .userInitiated:        return DispatchQueue.global(qos: .userInitiated)
        case .utility:              return DispatchQueue.global(qos: .utility)
        case .background:           return DispatchQueue.global(qos: .background)
        }
    }
}

现在您只需像这样延迟主线程上的代码：

delay(bySeconds: 1.5) { 
    // delayed code
}

如果您想将代码延迟到不同的线程：

delay(bySeconds: 1.5, dispatchLevel: .background) { 
    // delayed code that will run on background thread
}

如果您更喜欢具有一些更方便功能的框架，请查看 HandySwift。您可以通过 Carthage 将其添加到您的项目中，然后像上面的示例一样使用它，例如：

import HandySwift    

delay(bySeconds: 1.5) { 
    // delayed code
}

【讨论】：

【解决方案20】：

使用此代码在 2.0 秒后执行一些与 UI 相关的任务。

            let delay = 2.0
            let delayInNanoSeconds = dispatch_time(DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC)))
            let mainQueue = dispatch_get_main_queue()

            dispatch_after(delayInNanoSeconds, mainQueue, {

                print("Some UI related task after delay")
            })

Swift 3.0 版本

以下闭包函数在主线程延迟后执行一些任务。

func performAfterDelay(delay : Double, onCompletion: @escaping() -> Void){

    DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + delay, execute: {
       onCompletion()
    })
}

像这样调用这个函数：

performAfterDelay(delay: 4.0) {
  print("test")
}

【讨论】：

这与之前的答案几乎相同
这个答案似乎是在 2016 年初完成的，并且至少比其他 6 个答案更早。

【解决方案21】：

Swift 3.0 版本

以下闭包函数在主线程延迟后执行一些任务。

func performAfterDelay(delay : Double, onCompletion: @escaping() -> Void){

    DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + delay, execute: {
       onCompletion()
    })
}

像这样调用这个函数：

performAfterDelay(delay: 4.0) {
  print("test")
}

【讨论】：

【解决方案22】：

结构更清晰：

dispatch_after(when: dispatch_time_t, queue: dispatch_queue_t, block: dispatch_block_t?)

dispatch_time_t 是一个UInt64。 dispatch_queue_t 实际上是别名为NSObject 的类型，但您应该只使用您熟悉的 GCD 方法来获取队列。该块是一个 Swift 闭包。具体来说，dispatch_block_t 定义为() -> Void，相当于() -> ()。

示例用法：

let delayTime = dispatch_time(DISPATCH_TIME_NOW, Int64(1 * Double(NSEC_PER_SEC)))
dispatch_after(delayTime, dispatch_get_main_queue()) {
    print("test")
}

编辑：

我推荐使用@matt's really nice delay function。

编辑 2：

在 Swift 3 中，将有新的 GCD 包装器。见这里：https://github.com/apple/swift-evolution/blob/master/proposals/0088-libdispatch-for-swift3.md

原始示例将在 Swift 3 中编写如下：

let deadlineTime = DispatchTime.now() + .seconds(1)
DispatchQueue.main.asyncAfter(deadline: deadlineTime) {
    print("test")
}

请注意，您可以将deadlineTime 声明写为DispatchTime.now() + 1.0 并获得相同的结果，因为+ 运算符被如下覆盖（类似于-）：

func +(time: DispatchTime, seconds: Double) -> DispatchTime
func +(time: DispatchWalltime, interval: DispatchTimeInterval) -> DispatchWalltime

这意味着如果你不使用DispatchTimeIntervalenum而只写一个数字，则假定你使用的是秒。

【讨论】：

提示：因为块是函数的最后一个参数，你可以使用 Swift 的“尾随闭包”语法来增加可读性：dispatch_after(1, dispatch_get_main_queue()) { println("test") }
我认为在dispatch_after(1, ... 中使用数字1 可能会在这里引起很多混乱。人们会认为这是几秒钟，而实际上是纳秒。我建议查看@brindy 关于如何正确创建此号码的答案。
请将1 更改为dispatch_time(DISPATCH_TIME_NOW, Int64(1 * Double(NSEC_PER_SEC)))，因为这会导致混淆。人们可能认为您不需要在 Swift 中创建 dispatch_time_t
Swift 3 版本似乎无法正常工作。投诉Binary operator '+' cannot be applied to operands of type DispatchTime and '_'上线let delayTime = DispatchTime.now() + .seconds(1.0)
将其重写为DispatchTime.now() + 1.0 似乎是使其工作的唯一方法（不需要.seconds）

【解决方案23】：

在 Swift 3.0 中

调度队列

  DispatchQueue(label: "test").async {
        //long running Background Task
        for obj in 0...1000 {
            print("async \(obj)")
        }

        // UI update in main queue
        DispatchQueue.main.async(execute: { 
            print("UI update on main queue")
        })

    }

    DispatchQueue(label: "m").sync {
        //long running Background Task
        for obj in 0...1000 {
            print("sync \(obj)")
        }

        // UI update in main queue
        DispatchQueue.main.sync(execute: {
            print("UI update on main queue")
        })
    }

5秒后派送

    DispatchQueue.main.after(when: DispatchTime.now() + 5) {
        print("Dispatch after 5 sec")
    }

【讨论】：

【解决方案24】：

虽然不是 OP 的原始问题，但某些与 NSTimer 相关的问题已被标记为此问题的重复项，因此值得在此处包含 NSTimer 答案。

`NSTimer` 与 `dispatch_after`

NSTimer 级别较高，dispatch_after 级别较低。
NSTimer 更容易取消。取消dispatch_after 需要写more code。

使用`NSTimer` 延迟任务

创建一个NSTimer 实例。

var timer = NSTimer()

以您需要的延迟启动计时器。

// invalidate the timer if there is any chance that it could have been called before
timer.invalidate()
// delay of 2 seconds
timer = NSTimer.scheduledTimerWithTimeInterval(2.0, target: self, selector: #selector(delayedAction), userInfo: nil, repeats: false)

添加一个要在延迟后调用的函数（使用您用于上述selector 参数的任何名称）。

func delayedAction() {
    print("Delayed action has now started."
}

注意事项

如果您需要在操作发生之前取消操作，只需致电timer.invalidate()。
对于重复操作，请使用repeats: true。

如果您有一个不需要取消的一次性事件，则无需创建timer 实例变量。以下内容就足够了：

NSTimer.scheduledTimerWithTimeInterval(2.0, target: self, selector: #selector(delayedAction), userInfo: nil, repeats: false)

查看我的完整答案here。

【讨论】：

【解决方案25】：

matt's syntax 非常好，如果您需要使块无效，您可能需要使用它：

typealias dispatch_cancelable_closure = (cancel : Bool) -> Void

func delay(time:NSTimeInterval, closure:()->Void) ->  dispatch_cancelable_closure? {

    func dispatch_later(clsr:()->Void) {
        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 closure != nil {
            if (cancel == false) {
                dispatch_async(dispatch_get_main_queue(), closure!);
            }
        }
        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)
    }
}

如下使用

let retVal = delay(2.0) {
    println("Later")
}
delay(1.0) {
    cancel_delay(retVal)
}

credits

上面的链接好像失效了。 Original Objc code from Github

【讨论】：

具有 performSelector:afterDelay 的一项性能特性是能够取消它。只有这个解决方案才能解决问题。谢谢
@HotJard 请注意，performSelector:afterDelay: 现在在 Swift 2 中可用，因此您可以取消它。
@matt 但它仅适用于 NSObject，不是吗？
@HotJard 当然，但这总比没有好。我认为那里没有问题。然而，就像这个答案一样，我已经通过编写一个基于 GCD 的可取消计时器来弥补它的损失（使用 dispatch_source_t，因为这是你可以取消的东西）。
非常感谢，我一直在使用它直到 Swift 2.3。 Swift 3.0 编译器现在抱怨，如果你更新你的答案会很棒！

【解决方案26】：

另一种方法是像这样扩展 Double：

extension Double {
   var dispatchTime: dispatch_time_t {
       get {
           return dispatch_time(DISPATCH_TIME_NOW,Int64(self * Double(NSEC_PER_SEC)))
       }
   }
}

那么你可以这样使用它：

dispatch_after(Double(2.0).dispatchTime, dispatch_get_main_queue(), { () -> Void in
            self.dismissViewControllerAnimated(true, completion: nil)
    })

我喜欢 matt 的延迟功能，但出于偏好，我宁愿限制传递闭包。

【讨论】：

保留current queue!

用法：

Swift 3、Xcode 8 Seed 6 的更新

NSTimer 与 dispatch_after

使用NSTimer 延迟任务

注意事项

保留`current queue`!

`NSTimer` 与 `dispatch_after`

使用`NSTimer` 延迟任务