如果从UI线程调用，sleep会锁住你的程序，可以考虑使用NSTimer或分派计时器。

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

do {
    sleep(4)
}

这使用了UNIX中的睡眠函数。

Using a dispatch_after block is in most cases better than using sleep(time) as the thread on which the sleep is performed is blocked from doing other work. when using dispatch_after the thread which is worked on does not get blocked so it can do other work in the meantime. If you are working on the main thread of your application, using sleep(time) is bad for the user experience of your app as the UI is unresponsive during that time. Dispatch after schedules the execution of a block of code instead of freezing the thread:

斯威夫特≥ 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 {
    try await Task.sleep(nanoseconds: UInt64(seconds * Double(NSEC_PER_SEC)))
    // Put your code which should be executed with a delay here
}

Swift < 3.0

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
}

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的回答)是另一个有效的选项。然而，这很难取消。使用NSTimer，在延迟事件发生之前取消它，你所需要做的就是调用

timer.invalidate()

不建议使用sleep，特别是在主线程上，因为它会停止线程上正在完成的所有工作。

在这里可以看到我更完整的答案。

我同意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
}

如果你喜欢一个框架，也有一些更方便的功能，然后签出handysswift。你可以通过SwiftPM将它添加到你的项目中，然后像上面的例子一样使用它:

import HandySwift    

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

这是最简单的

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

在Swift 3.0中尝试以下实现

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

使用

delayWithSeconds(1) {
   //Do something
}

你也可以用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")
        }

要创建一个简单的时间延迟，您可以导入Darwin，然后使用sleep(秒)来执行延迟。不过，这只需要几秒钟的时间，所以为了更精确的测量，你可以导入Darwin并使用usleep(百万分之一秒)进行非常精确的测量。为了验证这一点，我写道:

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

打印，然后等待1秒打印，然后等待0.4秒打印。一切都如预期般顺利。

swift 3.0中不同方法的比较

1. 睡眠

此方法没有回调。将代码直接放在这一行之后，在4秒内执行。它将阻止用户迭代UI元素，如测试按钮，直到时间结束。虽然按钮在睡眠开始时有点冻结，但其他元素，如活动指示器仍在旋转而没有冻结。在休眠期间不能再次触发此操作。

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

2. 调度，执行和定时器

这三种方法的工作原理类似，它们都运行在后台线程上，并带有回调，只是语法和功能略有不同。

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

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

Perform实际上是一个简化的计时器。它设置一个具有延迟的计时器，然后通过选择器触发函数。

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

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

最后，timer还提供了重复回调的能力，这在这个例子中是没有用的

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


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

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

总之

这四种方法单独使用都不够好。Sleep将禁用用户交互，所以屏幕“冻结”(不是真的)，并导致糟糕的用户体验。其他三个方法不会冻结屏幕，但您可以多次触发它们，大多数情况下，您希望等待，直到您得到回调才允许用户再次进行调用。

所以更好的设计是使用三种带有屏幕阻塞的异步方法之一。当用户点击按钮时，用半透明的视图覆盖整个屏幕，顶部有一个旋转的活动指示器，告诉用户按钮点击正在被处理。然后删除回调函数中的视图和指示器，告诉用户操作已正确处理，等等。

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

如果需要将延迟设置为小于1秒，则不需要设置.seconds参数。我希望这对某些人有用。

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

在Swift 4.2和Xcode 10.1中

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

选项1。

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

}

第二个选项。

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。

如果你的代码已经在后台线程中运行，在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)
}

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

你可以创建扩展来轻松使用延迟函数(语法: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
})

作为之前建议的选项的替代解决方案，您可以使用基于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:)方法允许在指定的延迟之后继续执行程序的概率是多少。

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

使用DispatchQueue的. asyncafter方法，可以在给定时间后执行代码。例如，执行…在主线程中，1秒后看起来是这样的:

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

使用我方便的延迟包装器结构，你可以以更奇特的方式执行它:

struct Delay {

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

}

用法:

Delay(0.4) { ... }

斯威夫特5 <

使用任务。Sleep不会阻塞当前任务以外的任何代码，而且非常简单。

//Delay task by 4 seconds:

Task {
    try await Task.sleep(nanoseconds: 4000000000)
    //Execute your code here
}

我认为最简单和最新的4秒计时器方法是:

Task { 
    // Do something

    // Wait for 4 seconds
    try await Task.sleep(nanoseconds: 4_000_000_000) 

}

它使用了Swift 5.5的新并发。

这是添加延迟的一种更简单的方式，不会影响线程执行。

let continueTime: Date = Calendar.current.date(byAdding: .second, value: 30, to: Date())!
while (Date() < continueTime) {
    //DO NOTHING
}