objective-c dispatch_after - Swift 中的 GCD？

dispatch_after - GCD in Swift?

提问by Kumar KL

I've gone through the iBookfrom Apple, and couldn't find any definition of it:

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

Can someone explain the structure of dispatch_after?

有人能解释一下结构dispatch_after吗？

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

回答by matt

I use dispatch_afterso often that I wrote a top-level utility function to make the syntax simpler:

我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)
}

And now you can talk like this:

现在你可以这样说话：

delay(0.4) {
    // do stuff
}

Wow, a language where you can improve the language. What could be better?

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

---

---

Update for Swift 3, Xcode 8 Seed 6

Swift 3、Xcode 8 种子 6 的更新

Seems almost not worth bothering with, now that they've improved the calling syntax:

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

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

回答by Cezary Wojcik

A clearer idea of the structure:

更清晰的结构概念：

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

dispatch_time_tis a UInt64. The dispatch_queue_tis actually type aliased to an NSObject, but you should just use your familiar GCD methods to get queues. The block is a Swift closure. Specifically, dispatch_block_tis defined as () -> Void, which is equivalent to () -> ().

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

Example usage:

用法示例：

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

EDIT:

编辑：

I recommend using @matt's really nice delayfunction.

我建议使用@matt 的非常好的delay功能。

EDIT 2:

编辑2：

In Swift 3, there will be new wrappers for GCD. See here: https://github.com/apple/swift-evolution/blob/master/proposals/0088-libdispatch-for-swift3.md

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

The original example would be written as follows in Swift 3:

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

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

Note that you can write the deadlineTimedeclaration as DispatchTime.now() + 1.0and get the same result because the +operator is overridden as follows (similarly for -):

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

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

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

This means that if you don't use the DispatchTimeIntervalenumand just write a number, it is assumed that you are using seconds.

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

回答by brindy

Swift 3+

斯威夫特 3+

This is super-easy and elegant in Swift 3+:

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

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

Older Answer:

旧答案：

To expand on Cezary's answer, which will execute after 1 nanosecond, I had to do the following to execute after 4 and a half seconds.

为了扩展 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)

Edit: I discovered that my original code was slightly wrong. Implicit typing causes a compile error if you don't cast NSEC_PER_SEC to a Double.

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

If anyone can suggest a more optimal solution I'd be keen to hear it.

如果有人可以提出更优化的解决方案，我很想听听。

回答by Waam

matt's syntaxis very nice and if you need to invalidate the block, you may want to use this :

matt 的语法非常好，如果您需要使块无效，您可能需要使用这个：

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)
    }
}

Use as follow

使用如下

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

credits

学分

Link above seems to be down. Original Objc code from Github

上面的链接好像挂了。来自 Github 的原始 Objc 代码

回答by Vakas

Simplest solution in Swift 3.0 & Swift 4.0 & Swift 5.0

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

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

Usage

用法

delayWithSeconds(1) {
   //Do something
}

回答by Senseful

Apple has a dispatch_after snippetfor Objective-C:

Apple 有一个用于Objective-C的dispatch_after 片段：

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#>
});

Here is the same snippet ported to Swift3:

这是移植到Swift3的相同片段：

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

回答by garafajon

Another way is to extend Double like this:

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

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

Then you can use it like this:

然后你可以像这样使用它：

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

I like matt's delay function but just out of preference I'd rather limit passing closures around.

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

回答by Mohammad Sadiq Shaikh

In Swift 3.0

在 Swift 3.0 中

Dispatch queues

调度队列

  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")
        })
    }

Dispatch after 5 seconds

5秒后发送

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

回答by Himanshu Mahajan

Swift 3.0 version

斯威夫特 3.0 版本

Following closure function execute some task after delay on main thread.

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

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

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

Call this function like:

像这样调用这个函数：

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

回答by A.G

1) Add this method as a part of UIViewController Extension.

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

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)
    }
}

Call this method on VC:

在 VC 上调用这个方法：

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

2)

2)

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

3)

3)

override func viewWillAppear(animated: Bool) {

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

//Compact Form

//紧凑型

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