如何在 Swift 中创建延迟？

Question

我想在某个时间点暂停我的应用程序。换句话说，我希望我的应用程序执行代码，然后在某个时间点暂停 4 秒，然后继续执行其余代码。我该怎么做？

我正在使用 Swift。

Answer 1

在大多数情况下，使用dispatch_after 块比使用sleep(time) 更好，因为执行睡眠的线程被阻止执行其他工作。当使用dispatch_after 时，正在处理的线程不会被阻塞，因此它可以同时进行其他工作。
如果您正在处理应用程序的主线程，则使用 sleep(time) 不利于应用程序的用户体验，因为在此期间 UI 无响应。

调度后调度代码块的执行而不是冻结线程：

斯威夫特≥3.0

let seconds = 4.0
DispatchQueue.main.asyncAfter(deadline: .now() + seconds) {
    // Put your code which should be executed with a delay here
}

在异步上下文中 Swift ≥ 5.5：

func foo() async {
    await Task.sleep(UInt64(seconds * Double(NSEC_PER_SEC)))
    // Put your code which should be executed with a delay here
}

斯威夫特

let time = dispatch_time(dispatch_time_t(DISPATCH_TIME_NOW), 4 * Int64(NSEC_PER_SEC))
dispatch_after(time, dispatch_get_main_queue()) {
    // Put your code which should be executed with a delay here
}

Answer 2

考虑使用NSTimer 或调度计时器，而不是睡眠（如果从 UI 线程调用会锁定您的程序）。

但是，如果你真的需要当前线程的延迟：

do {
    sleep(4)
}

这使用了来自 UNIX 的 sleep 函数。

Answer 3

swift 3.0中不同方法的比较

1.睡觉

此方法没有回调。将代码直接放在此行之后以在 4 秒内执行。它将阻止用户使用 UI 元素（如测试按钮）进行迭代，直到时间结束。尽管在睡眠开始时按钮有点冻结，但活动指示器等其他元素仍在旋转而没有冻结。您无法在睡眠期间再次触发此操作。

sleep(4)
print("done")//Do stuff here

2。调度、执行和计时器

这三个方法的工作方式类似，都是在后台线程上运行，有回调，只是语法不同，功能略有不同。

Dispatch 通常用于在后台线程上运行某些东西。它有回调作为函数调用的一部分

DispatchQueue.main.asyncAfter(deadline: .now() + .seconds(4), execute: {
    print("done")
})

Perform 实际上是一个简化的计时器。它设置一个带有延迟的定时器，然后通过选择器触发该功能。

perform(#selector(callback), with: nil, afterDelay: 4.0)

func callback() {
    print("done")
}}

最后，定时器还提供了重复回调的能力，这在这种情况下是没有用的

Timer.scheduledTimer(timeInterval: 4, target: self, selector: #selector(callback), userInfo: nil, repeats: false)


func callback() {
    print("done")
}}

对于所有这三种方法，当您单击按钮触发它们时，UI 不会冻结，您可以再次单击它。如果再次点击该按钮，则会设置另一个计时器并触发两次回调。

总结

这四种方法都不能单独使用。 sleep 将禁用用户交互，因此屏幕“冻结”（实际上并非如此）并导致糟糕的用户体验。其他三种方法不会冻结屏幕，但您可以多次触发它们，而且大多数情况下，您希望等到您收到回电后再允许用户再次拨打电话。

因此，更好的设计是使用三种异步方法中的一种来屏蔽屏幕。当用户点击按钮时，用一些半透明视图覆盖整个屏幕，顶部有一个旋转的活动指示器，告诉用户正在处理按钮点击。然后移除回调函数中的view和indicator，告诉用户该action被正确处理等等。

Answer 4

在 Swift 4.2 和 Xcode 10.1 中

您总共有 4 种方法可以延迟。在这些选项1中，最好在一段时间后调用或执行一个函数。 sleep() 是最少使用的情况。

选项 1。

DispatchQueue.main.asyncAfter(deadline: .now() + 5.0) {
    self.yourFuncHere()
}
//Your function here    
func yourFuncHere() {

}

选项 2。

perform(#selector(yourFuncHere2), with: nil, afterDelay: 5.0)

//Your function here  
@objc func yourFuncHere2() {
    print("this is...")
}

选项 3。

Timer.scheduledTimer(timeInterval: 5.0, target: self, selector: #selector(yourFuncHere3), userInfo: nil, repeats: false)

//Your function here  
@objc func yourFuncHere3() {

}

选项 4。

sleep(5)

如果您想在一段时间后调用一个函数来执行某事，请不要使用 sleep。

Answer 5

我同意 Palle 的观点，即在这里使用dispatch_after 是一个不错的选择。但您可能不喜欢 GCD 调用，因为它们写起来很烦人。相反，您可以添加这个方便的助手：

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, dispatchLevel: .background) { 
    // delayed code that will run on background thread
}

主线程上的延迟代码更简单：

delay(bySeconds: 1.5) { 
    // delayed code, by default run in main thread
}

---

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

import HandySwift    

delay(by: .seconds(1.5)) { 
    // delayed code
}

Answer 6

您也可以使用 Swift 3 来做到这一点。

像这样延迟后执行函数。

override func viewDidLoad() {
    super.viewDidLoad()

    self.perform(#selector(ClassName.performAction), with: nil, afterDelay: 2.0)
}


     @objc func performAction() {
//This function will perform after 2 seconds
            print("Delayed")
        }

Answer 7

NSTimer

@nneonneo 的回答建议使用NSTimer，但没有说明如何操作。这是基本语法：

let delay = 0.5 // time in seconds
NSTimer.scheduledTimerWithTimeInterval(delay, target: self, selector: #selector(myFunctionName), userInfo: nil, repeats: false)

这是一个非常简单的项目来展示如何使用它。当按下按钮时，它会启动一个计时器，该计时器将在半秒延迟后调用一个函数。

import UIKit
class ViewController: UIViewController {

    var timer = NSTimer()
    let delay = 0.5
    
    // start timer when button is tapped
    @IBAction func startTimerButtonTapped(sender: UIButton) {

        // cancel the timer in case the button is tapped multiple times
        timer.invalidate()

        // start the timer
        timer = NSTimer.scheduledTimerWithTimeInterval(delay, target: self, selector: #selector(delayedAction), userInfo: nil, repeats: false)
    }

    // function to be called after the delay
    func delayedAction() {
        print("action has started")
    }
}

使用dispatch_time（如Palle's answer）是另一个有效选项。但是，它是hard to cancel。使用NSTimer，要在延迟事件发生之前取消它，您需要做的就是调用

timer.invalidate()

不推荐使用sleep，尤其是在主线程上，因为它会停止在线程上完成的所有工作。

请参阅 here 以获得更完整的答案。

Answer 8

在 Swift 3.0 中尝试以下实现

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

用法

delayWithSeconds(1) {
   //Do something
}

Answer 9

如果需要设置小于一秒的延迟，则无需设置 .seconds 参数。我希望这对某人有用。

DispatchQueue.main.asyncAfter(deadline: .now() + 0.5, execute: {
        // your code hear
})

Answer 10

您可以轻松创建扩展以使用延迟功能（语法：Swift 4.2+）

extension UIViewController {
    func delay(_ delay:Double, closure:@escaping ()->()) {
        DispatchQueue.main.asyncAfter(
            deadline: DispatchTime.now() + Double(Int64(delay * Double(NSEC_PER_SEC))) / Double(NSEC_PER_SEC), execute: closure)
    }
}

如何在 UIViewController 中使用

self.delay(0.1, closure: {
   //execute code
})

Answer 11

如果您的代码已经在后台线程中运行，请使用 this method in Foundation 暂停线程：Thread.sleep(forTimeInterval:)

例如：

DispatchQueue.global(qos: .userInitiated).async {

    // Code is running in a background thread already so it is safe to sleep
    Thread.sleep(forTimeInterval: 4.0)
}

（当您的代码在主线程上运行时，请参阅其他答案以获得建议。）

Answer 12

DispatchQueue.global(qos: .background).async {
    sleep(4)
    print("Active after 4 sec, and doesn't block main")
    DispatchQueue.main.async{
        //do stuff in the main thread here
    }
}

Answer 13

要创建一个简单的时间延迟，您可以导入 Darwin，然后使用 sleep(seconds) 进行延迟。不过，这只需要整整几秒钟，因此对于更精确的测量，您可以导入 Darwin 并使用 usleep（百万分之一秒）进行非常精确的测量。为了测试这一点，我写道：

import Darwin
print("This is one.")
sleep(1)
print("This is two.")
usleep(400000)
print("This is three.")

哪个打印，然后等待 1 秒并打印，然后等待 0.4 秒然后打印。一切都按预期工作。

Answer 14

作为之前提出的选项的替代解决方案，您可以使用基于 DispatchGroup 类的延迟，该类旨在同步执行多个异步任务：

print("Start")
print(Date())

let delay = DispatchTimeInterval.seconds(3)
let group = DispatchGroup()
group.enter()
_ = group.wait(timeout: .now() + delay)

print("Finish")
print(Date())

其中enter() 方法用于显式指示组代码的执行已经开始，wait(timeout:) 方法用于等待组任务完成。当然，在这个例子中这永远不会发生，为此指定了一个超时，它等于所需的延迟。

作为现成的助手使用很方便：

public class DispatchWait {
    private init () { }
    
    public static func `for` (_ interval: DispatchTimeInterval) {
        let group = DispatchGroup()
        group.enter()
        _ = group.wait(timeout: .now().advanced(by: interval))
    }
}

一个使用DispatchWait的例子：

print("Start")
print(Date())

DispatchWait.for(.seconds(3))

print("Finish")
print(Date())

不幸的是，我不能说这个延迟的准确性是多少，以及wait(timeout:) 方法允许程序在指定延迟之后进一步执行的概率是多少。

此外，此解决方案允许您延迟当前队列中的代码，而无需在单独的闭包中执行它。

Answer 15

使用DispatchQueue 的.asyncAfter 方法，您可以在给定时间后执行代码。所以，例如1 秒后在主线程上执行 ... 如下所示：

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

使用我方便的 Delay 包装结构，您可以以更奇特的方式执行它：

struct Delay {

    @discardableResult
    init(_ timeInterval: TimeInterval, queue: DispatchQueue = .main, executingBlock: @escaping () -> Void) {
        queue.asyncAfter(deadline: .now() + timeInterval, execute: executingBlock)
    }

}

用法：

Delay(0.4) { ... }

Answer 16

这是最简单的

    delay(0.3, closure: {
        // put her any code you want to fire it with delay
        button.removeFromSuperview()   
    })