ฉันจะเขียน dispatch_after GCD ใน Swift 3, 4 และ 5 ได้อย่างไร

ใน 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เป็นDoubleน่าจะเป็นแหล่งที่มาของความสับสน (ESP ตั้งแต่เราได้คุ้นเคยกับการเพิ่ม nsec บริการ) "เพิ่มวินาทีในขณะที่Double" ไวยากรณ์ใช้งานได้เนื่องจากdeadlineเป็นDispatchTimeและหลังฉากมี+โอเปอเรเตอร์ที่จะใช้เวลาDoubleและเพิ่มจำนวนวินาทีนั้นในDispatchTime:

public func +(time: DispatchTime, seconds: Double) -> DispatchTime

แต่ถ้าคุณอยากจะเพิ่มเต็มจำนวนมิลลิวินาที, ไมโครวินาทีหรือ nsec ไปDispatchTimeคุณยังสามารถเพิ่มไปยังDispatchTimeInterval 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การทำเช่นนี้การใช้งาน ตัวอย่างเช่นสิ่งนี้จะเริ่มงานที่จะดำเนินการภายในห้าวินาทีหรือหากตัวควบคุมมุมมองถูกยกเลิกและยกเลิกการจัดสรรคืนงาน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.main.asyncAfter(deadline: .now() + 0.1 + .milliseconds(500) + 
.microseconds(500) + .nanoseconds(1000)) {
                print("Delayed by 0.1 second + 500 milliseconds + 500 microseconds + 
                      1000 nanoseconds)")
 }

สวิฟต์ 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")
}

โทร 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
}

Swift 5 ขึ้นไป

DispatchQueue.main.asyncAfter(deadline: .now() + 2, execute: {
   // code to execute                 
})

ไม่มีคำตอบที่กล่าวถึงที่ทำงานอยู่บนเธรดที่ไม่ใช่ main ดังนั้นเพิ่ม 2 cents ของฉัน

บนคิวหลัก (เธรดหลัก)

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) {
    // ...
}

สิ่งนี้ใช้ได้กับฉันใน 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)")
}

คุณสามารถใช้ได้

DispatchQueue.main.asyncAfter(deadline: .now() + .microseconds(100)) {
        // Code
    }

ลองนี้

let when = DispatchTime.now() + 1.5
    DispatchQueue.main.asyncAfter(deadline: when) {
        //some code
    }