在 Swift 2 中，我可以dispatch_after使用大中央调度来延迟一个动作：
var dispatchTime: dispatch_time_t = dispatch_time(DISPATCH_TIME_NOW, Int64(0.1 * Double(NSEC_PER_SEC)))
dispatch_after(dispatchTime, dispatch_get_main_queue(), {
// your function here
})
但这似乎从 Swift 3 开始不再编译。在现代 Swift 中编写它的首选方法是什么？
语法很简单：
// to run something in 0.1 seconds
DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
// your code here
}
请注意，上述添加seconds为 a的语法Double似乎是混淆的来源（尤其是因为我们习惯于添加 nsec）。“将秒数添加为Double”语法之所以有效，是因为deadline它是 aDispatchTime并且在幕后，有一个+运算符将采用 aDouble并将那么多秒数添加到DispatchTime：
public func +(time: DispatchTime, seconds: Double) -> DispatchTime
但是，如果您真的想将整数 msec、μs 或 nsec 添加到DispatchTime，您也可以将 a 添加DispatchTimeInterval到 a DispatchTime。这意味着你可以这样做：
DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(500)) {
os_log("500 msec seconds later")
}
DispatchQueue.main.asyncAfter(deadline: .now() + .microseconds(1_000_000)) {
os_log("1m μs seconds later")
}
DispatchQueue.main.asyncAfter(deadline: .now() + .nanoseconds(1_500_000_000)) {
os_log("1.5b nsec seconds later")
}
+由于类中运算符的这种单独的重载方法，这些都可以无缝地工作DispatchTime。
public func +(time: DispatchTime, interval: DispatchTimeInterval) -> DispatchTime
有人询问如何取消已分派的任务。为此，请使用DispatchWorkItem. 例如，这将启动一个将在 5 秒内触发的任务，或者如果视图控制器被解除并释放，deinit它将取消该任务：
class ViewController: UIViewController {
private var item: DispatchWorkItem?
override func viewDidLoad() {
super.viewDidLoad()
item = DispatchWorkItem { [weak self] in
self?.doSomething()
self?.item = nil
}
DispatchQueue.main.asyncAfter(deadline: .now() + 5, execute: item!)
}
deinit {
item?.cancel()
}
func doSomething() { ... }
}
注意[weak self]在DispatchWorkItem. 这对于避免强参考循环至关重要。另请注意，这不会进行抢先取消，而只是阻止任务启动（如果尚未启动）。但是，如果它在遇到调用时已经启动，则cancel()该块将完成其执行（除非您在isCancelled块内手动检查）。
斯威夫特 4：
DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(100)) {
// Code
}
对于时间.seconds(Int)，.microseconds(Int)也.nanoseconds(Int)可以使用。
如果你只想要延迟功能
斯威夫特 4 & 5
func delay(interval: TimeInterval, closure: @escaping () -> Void) {
DispatchQueue.main.asyncAfter(deadline: .now() + interval) {
closure()
}
}
你可以像这样使用它：
delay(interval: 1) {
print("Hi!")
}
在 Swift 3 发布之后，还必须添加 @escaping
func delay(_ delay: Double, closure: @escaping () -> ()) {
DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
closure()
}
}
斯威夫特 4
您可以在 DispatchQueue 上创建扩展并添加在DispatchQueue内部使用 asyncAfter 函数的函数延迟
extension DispatchQueue {
static func delay(_ delay: DispatchTimeInterval, closure: @escaping () -> ()) {
DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: closure)
}
}
并使用
DispatchQueue.delay(.milliseconds(10)) {
print("task to be done")
}
接受的答案有点不同的味道。
斯威夫特 4
DispatchQueue.main.asyncAfter(deadline: .now() + 0.1 + .milliseconds(500) +
.microseconds(500) + .nanoseconds(1000)) {
print("Delayed by 0.1 second + 500 milliseconds + 500 microseconds +
1000 nanoseconds)")
}
称呼DispatchQueue.main.after(when: DispatchTime, execute: () -> Void)
我强烈建议使用 Xcode 工具转换为 Swift 3（编辑 > 转换 > 到当前的 Swift 语法）。它为我捕捉到了这个
在 Swift 4.1 和 Xcode 9.4.1
简单的答案是...
//To call function after 5 seconds time
DispatchQueue.main.asyncAfter(deadline: .now() + 5.0) {
//Here call your function
}
斯威夫特 5 及以上
DispatchQueue.main.asyncAfter(deadline: .now() + 2, execute: {
// code to execute
})
没有提到在非主线程上运行的答案，所以加上我的 2 美分。
在主队列（主线程）
let mainQueue = DispatchQueue.main
let deadline = DispatchTime.now() + .seconds(10)
mainQueue.asyncAfter(deadline: deadline) {
// ...
}
或者
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + .seconds(10)) {
// ...
}
在全局队列上（非主线程，基于指定的 QOS）。
let backgroundQueue = DispatchQueue.global()
let deadline = DispatchTime.now() + .milliseconds(100)
backgroundQueue.asyncAfter(deadline: deadline, qos: .background) {
// ...
}
或者
DispatchQueue.global().asyncAfter(deadline: DispatchTime.now() + .milliseconds(100), qos: .background) {
// ...
}
您可以使用
DispatchQueue.main.asyncAfter(deadline: .now() + .microseconds(100)) {
// Code
}
试试这个
let when = DispatchTime.now() + 1.5
DispatchQueue.main.asyncAfter(deadline: when) {
//some code
}