Objective c Swift中GCD后的调度？_Objective C_Swift_Grand Central Dispatch

Objective c Swift中GCD后的调度？

objective-c swift

Objective c Swift中GCD后的调度？,objective-c,swift,grand-central-dispatch,Objective C,Swift,Grand Central Dispatch,我浏览了苹果公司的网站，找不到它的任何定义：有人能解释一下后调度单元的结构吗 dispatch_after(<#when: dispatch_time_t#>, <#queue: dispatch_queue_t?#>, <#block: dispatch_block_t?#>) （，）之后的调度更清楚地了解结构： dispatch_after(when: dispatch_time_t, queue: dispatch_queue_t, block:

我浏览了苹果公司的网站，找不到它的任何定义：

有人能解释一下

后调度单元的结构吗
dispatch_after(<#when: dispatch_time_t#>, <#queue: dispatch_queue_t?#>, <#block: dispatch_block_t?#>)

（，）之后的调度

更清楚地了解结构：

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

dispatch\u time\t

是一个

UInt64

。

dispatch\u queue\t

实际上是一个名为

NSObject

的类型别名，但是您应该使用熟悉的GCD方法来获取队列。这座街区很快就关闭了。具体而言，

调度块

定义为

（）->Void

，相当于

（）->（）

用法示例：

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

编辑：

我建议使用

编辑2:

在Swift 3中，将为GCD提供新的包装。请看这里：

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

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

请注意，您可以将

deadlineTime

声明编写为

DispatchTime.now（）+1.0

，并获得相同的结果，因为

运算符被覆盖如下（类似于

）：

func+（时间：DispatchTime，秒数：双）->DispatchTime

func+（时间：DispatchWalltime，间隔：DispatchTimeInterval）->DispatchWalltime

这意味着，如果您不使用

DispatchTimeInterval

enum

只写一个数字，则假定您使用的是秒。

Swift 3+

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

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

旧答案：

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

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_second强制转换为Double，则隐式键入会导致编译错误

如果有人能提出一个更为优化的解决方案，我会非常乐意听到。

我经常在之后使用

dispatch\u，因此我编写了一个顶级实用函数来简化语法：
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
}

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

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

哇，这是一种可以提高语言水平的语言。还有什么更好的

Swift 3、Xcode 8和Seed 6的更新
现在他们已经改进了调用语法，似乎不值得费心：
func delay(_ delay:Double, closure:@escaping ()->()) {
    let when = DispatchTime.now() + delay
    DispatchQueue.main.asyncAfter(deadline: when, execute: closure)
}

非常好，如果需要使块无效，您可能希望使用以下方法：
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)
}


上面的链接似乎已关闭
 另一种方法是像这样扩展Double：
delay(0.4) {
    // do stuff
}

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

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

然后你可以这样使用它：
delay(0.4) {
    // do stuff
}

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

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

我喜欢matt的延迟函数，但出于偏好，我宁愿限制传递闭包。
苹果公司在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#>
});

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

dispatch\u在（dispatch\u time（dispatch\u time\u NOW，（int64\u t）（*NSEC\u PER\u SEC）），dispatch\u get\u main\u queue（）之后^{
});

下面是移植到Swift3的相同片段：
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + <#delayInSeconds#>) {
  <#code to be executed after a specified delay#>
}

DispatchQueue.main.asyncAfter（截止日期：DispatchTime.now（）+）{
}
使用此代码在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()
    })
}

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

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

调用此函数，如下所示：
performAfterDelay(delay: 4.0) {
  print("test")
}

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

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

在VC上调用此方法：
    self.runAfterDelay(5.0, block: {
     //Add code to this block
        print("run After Delay Success")
    })

(二)
(三)
//紧凑型
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 2), dispatch_get_main_queue()) {
    //Code here
 }
}

虽然不是OP的原始问题，但某些与NSTimer
相关的问题已被标记为该问题的副本，因此值得在此处包含NSTimer
答案
NSTimer
vsdispatch\u后

NSTimer
的级别更高，而dispatch\u after
的级别更低
NSTimer
更容易取消。在

之后取消

dispatch\u需要写入

使用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) 

添加一个要在延迟后调用的函数（使用上面选择器参数使用的任何名称）
笔记

如果需要在操作发生之前取消操作，只需调用timer.invalidate（）
对于重复操作，请使用repeats:true

如果您有一个不需要取消的一次性事件，则无需创建计时器
实例变量。以下几点就足够了：
NSTimer.scheduledTimerWithTimeInterval(2.0, target: self, selector: #selector(delayedAction), userInfo: nil, repeats: false) 


看我更完整的回答
另一个帮助程序，用于延迟使用率100%快速的代码，并允许选择不同的线程运行延迟的代码：
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(0.4) {
    // do stuff
}

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

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

如果要将代码延迟到其他线程：
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#>
});

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


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

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

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

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

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

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

5秒后发送
  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")
        })
    }

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

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

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

Swift 3.0、Swift 4.0和Swift 5.0中最简单的解决方案
func delayWithSeconds(_ seconds: Double, completion: @escaping () -> ()) {
    DispatchQueue.main.asyncAfter(deadline: .now() + seconds) { 
        completion()
    }
}

用法
Swift 3.0版
下面的闭包函数在主线程上延迟后执行一些任务
func performAfterDelay(delay : Double, onCompletion: @escaping() -> Void){

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

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

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

调用此函数，如下所示：
performAfterDelay(delay: 4.0) {
  print("test")
}

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

这对我有用
Swift 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);
});

现在，Swift中的Grand Central Dispatch（GCD）中的异步调度已超过语法糖
添加播客文件
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")
}

我总是喜欢使用扩展而不是自由函数。
DispatchQueue.main.asyncAfter(deadline: .now() + 0.9) {
            // Call your function 1
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                // Call your function 2
            }
        }

*// 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()
                }
            }

斯威夫特4
使用方法如下
DispatchQueue.performAction(after: 0.3) {
  // Code Here
}

Swift 4有一个非常简单的方法：
Timer.scheduledTimer(withTimeInterval: 2, repeats: false) { (timer) in
    // Your stuff here
    print("hello")
}

Swift 3&4:
您可以创建一个扩展