Bagaimana cara saya menulis dispatch_after GCD di Swift 3, 4, dan 5?

Di Swift 2, saya bisa menggunakan dispatch_afteruntuk menunda tindakan menggunakan grand central dispatch:

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

Tetapi ini sepertinya tidak lagi dikompilasi sejak Swift 3. Apa cara yang disukai untuk menulis ini dalam Swift modern?

Sintaksnya sederhana:

// to run something in 0.1 seconds

DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
    // your code here
}

Catatan, sintaksis menambahkan di secondsatas Doubletampaknya menjadi sumber kebingungan (terutama karena kita terbiasa menambahkan nsec). DoubleSintaks "tambahkan detik sebagai " berfungsi karena deadlinemerupakan DispatchTimedan, di belakang layar, ada +operator yang akan mengambil Doubledan menambahkan banyak detik ke DispatchTime:

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

Tetapi, jika Anda benar-benar ingin menambahkan bilangan bulat dari msec, μs, atau nsec ke DispatchTime, Anda juga dapat menambahkan a DispatchTimeIntervalke a DispatchTime. Itu berarti Anda dapat melakukan:

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

Ini semua berjalan mulus karena metode kelebihan beban yang terpisah ini untuk +operator di DispatchTimekelas.

public func +(time: DispatchTime, interval: DispatchTimeInterval) -> DispatchTime

Ditanya bagaimana seseorang membatalkan tugas yang dikirim. Untuk melakukan ini, gunakan DispatchWorkItem. Misalnya, ini memulai tugas yang akan diaktifkan dalam lima detik, atau jika pengontrol tampilan diberhentikan dan tidak dialokasikan, tugasnya deinitakan dibatalkan:

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

}

Perhatikan penggunaan [weak self]daftar tangkap di DispatchWorkItem. Ini penting untuk menghindari siklus referensi yang kuat. Perhatikan juga bahwa ini tidak melakukan pembatalan preemptive, tetapi hanya menghentikan tugas dari memulai jika belum. Tetapi jika sudah dimulai saat bertemu dengan cancel()panggilan, blok akan menyelesaikan eksekusi (kecuali jika Anda secara manual memeriksa isCancelleddi dalam blok).

Swift 4:

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

Untuk saat ini .seconds(Int), .microseconds(Int)dan .nanoseconds(Int)dapat juga digunakan.

Jika Anda hanya ingin fungsi penundaan di

Swift 4 & 5

func delay(interval: TimeInterval, closure: @escaping () -> Void) {
     DispatchQueue.main.asyncAfter(deadline: .now() + interval) {
          closure()
     }
}

Anda bisa menggunakannya seperti:

delay(interval: 1) { 
    print("Hi!")
}

setelah rilis Swift 3, @escaping juga harus ditambahkan

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

Rasa yang agak berbeda dari Jawaban yang Diterima.

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

Cepat 4

Anda dapat membuat ekstensi di DispatchQueue dan menambahkan penundaan fungsi yang menggunakan DispatchQueuefungsi asyncAfter secara internal

extension DispatchQueue {
   static func delay(_ delay: DispatchTimeInterval, closure: @escaping () -> ()) {
      DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: closure)
   }
}

dan gunakan

DispatchQueue.delay(.milliseconds(10)) {
   print("task to be done")
}

panggilan DispatchQueue.main.after(when: DispatchTime, execute: () -> Void)

Saya sangat merekomendasikan menggunakan alat Xcode untuk mengkonversi ke Swift 3 (Edit> Convert> To Current Swift Syntax). Ini menangkap ini untukku

Dalam Swift 4.1 dan Xcode 9.4.1

Jawaban sederhana adalah ...

//To call function after 5 seconds time
DispatchQueue.main.asyncAfter(deadline: .now() + 5.0) {
//Here call your function
}

Cepat 5 dan lebih tinggi

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

Tidak ada jawaban yang disebutkan berjalan di utas non-utama, jadi tambahkan 2 sen saya.

Di antrian utama (utas utama)

let mainQueue = DispatchQueue.main
let deadline = DispatchTime.now() + .seconds(10)
mainQueue.asyncAfter(deadline: deadline) {
    // ...
}

ATAU

DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + .seconds(10)) { 
    // ...
}

Pada antrian global (utas bukan utama, berdasarkan QOS yang ditentukan).

let backgroundQueue = DispatchQueue.global()
let deadline = DispatchTime.now() + .milliseconds(100)
backgroundQueue.asyncAfter(deadline: deadline, qos: .background) { 
    // ...
}

ATAU

DispatchQueue.global().asyncAfter(deadline: DispatchTime.now() + .milliseconds(100), qos: .background) {
    // ...
}

Ini bekerja untuk saya di 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)")
}

Kamu bisa menggunakan

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

coba ini

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