ฉันผ่านiBookจาก Apple และไม่พบคำจำกัดความใด ๆ ของมัน:

คนที่สามารถอธิบายโครงสร้างของdispatch_after?

dispatch_after(<#when: dispatch_time_t#>, <#queue: dispatch_queue_t?#>, <#block: dispatch_block_t?#>)

ความคิดที่ชัดเจนของโครงสร้าง:

dispatch_after(when: dispatch_time_t, queue: dispatch_queue_t, block: dispatch_block_t?)

dispatch_time_tUInt64เป็น วิธีdispatch_queue_tนี้ใช้นามแฝงเป็นจริงNSObjectแต่คุณควรใช้วิธี GCD ที่คุ้นเคยเพื่อรับคิว บล็อกคือการปิดอย่างรวดเร็ว โดยเฉพาะdispatch_block_tหมายถึง() -> Voidซึ่งเทียบเท่ากับ() -> ()ซึ่งเทียบเท่ากับ

ตัวอย่างการใช้งาน:

let delayTime = dispatch_time(DISPATCH_TIME_NOW, Int64(1 * Double(NSEC_PER_SEC)))
dispatch_after(delayTime, dispatch_get_main_queue()) {
    print("test")
}

แก้ไข:

ผมขอแนะนำให้ใช้@ ดีจริงๆด้านของdelayฟังก์ชั่น

แก้ไข 2:

ใน Swift 3 จะมี wrapper ใหม่สำหรับ GCD ดูที่นี่: https://github.com/apple/swift-evolution/blob/master/proposals/0088-libdispatch-for-swift3.md

ตัวอย่างต้นฉบับจะถูกเขียนดังต่อไปนี้ใน Swift 3:

let deadlineTime = DispatchTime.now() + .seconds(1)
DispatchQueue.main.asyncAfter(deadline: deadlineTime) {
    print("test")
}

โปรดทราบว่าคุณสามารถเขียนการdeadlineTimeประกาศเป็นDispatchTime.now() + 1.0และรับผลลัพธ์เดียวกันเนื่องจากตัว+ดำเนินการถูกเขียนทับดังนี้ (คล้ายกัน-):

• func +(time: DispatchTime, seconds: Double) -> DispatchTime
• func +(time: DispatchWalltime, interval: DispatchTimeInterval) -> DispatchWalltime

ซึ่งหมายความว่าหากคุณไม่ได้ใช้DispatchTimeInterval enumและเพียงแค่เขียนตัวเลขก็จะถือว่าคุณกำลังใช้วินาที

ฉันใช้dispatch_afterบ่อยครั้งที่ฉันเขียนฟังก์ชั่นยูทิลิตี้ระดับบนสุดเพื่อทำให้ไวยากรณ์ง่ายขึ้น:

func delay(delay:Double, closure:()->()) {
    dispatch_after(
        dispatch_time(
            DISPATCH_TIME_NOW,
            Int64(delay * Double(NSEC_PER_SEC))
        ),
        dispatch_get_main_queue(), closure)
}

และตอนนี้คุณสามารถพูดเช่นนี้:

delay(0.4) {
    // do stuff
}

ว้าวภาษาที่คุณสามารถปรับปรุงภาษาได้ อะไรจะดีไปกว่านี้?

อัปเดตสำหรับ Swift 3, Xcode 8 Seed 6

ดูเหมือนว่าแทบจะไม่คุ้มค่าเลยตอนนี้พวกเขาได้ปรับปรุงไวยากรณ์การโทร:

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

Swift 3+

นี่คือสุดยอดและใช้งานง่ายใน Swift 3+:

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

คำตอบที่เก่ากว่า:

เพื่อขยายคำตอบของ Cezary ซึ่งจะทำงานหลังจาก 1 nanosecond ฉันต้องทำต่อไปนี้เพื่อดำเนินการหลังจาก 4 และครึ่งวินาที

let delay = 4.5 * Double(NSEC_PER_SEC)
let time = dispatch_time(DISPATCH_TIME_NOW, Int64(delay))
dispatch_after(time, dispatch_get_main_queue(), block)

แก้ไข: ฉันค้นพบว่ารหัสดั้งเดิมของฉันผิดเล็กน้อย การพิมพ์โดยนัยทำให้เกิดข้อผิดพลาดในการคอมไพล์ถ้าคุณไม่ส่ง NSEC_PER_SEC ไปที่ Double

หากใครสามารถแนะนำวิธีแก้ปัญหาที่เหมาะสมที่สุดฉันก็อยากได้ยิน

ไวยากรณ์ของ mattนั้นดีมากและหากคุณต้องการทำให้บล็อกเป็นโมฆะคุณอาจต้องการใช้สิ่งนี้:

typealias dispatch_cancelable_closure = (cancel : Bool) -> Void

func delay(time:NSTimeInterval, closure:()->Void) ->  dispatch_cancelable_closure? {

    func dispatch_later(clsr:()->Void) {
        dispatch_after(
            dispatch_time(
                DISPATCH_TIME_NOW,
                Int64(time * Double(NSEC_PER_SEC))
            ),
            dispatch_get_main_queue(), clsr)
    }

    var closure:dispatch_block_t? = closure
    var cancelableClosure:dispatch_cancelable_closure?

    let delayedClosure:dispatch_cancelable_closure = { cancel in
        if closure != nil {
            if (cancel == false) {
                dispatch_async(dispatch_get_main_queue(), closure!);
            }
        }
        closure = nil
        cancelableClosure = nil
    }

    cancelableClosure = delayedClosure

    dispatch_later {
        if let delayedClosure = cancelableClosure {
            delayedClosure(cancel: false)
        }
    }

    return cancelableClosure;
}

func cancel_delay(closure:dispatch_cancelable_closure?) {

    if closure != nil {
        closure!(cancel: true)
    }
}

ใช้ดังต่อไปนี้

let retVal = delay(2.0) {
    println("Later")
}
delay(1.0) {
    cancel_delay(retVal)
}

เครดิต

ลิงค์ด้านบนดูเหมือนว่าจะลง รหัส Objc ดั้งเดิมจาก Github

ทางออกที่ง่ายที่สุดใน Swift 3.0 และ Swift 4.0 และ Swift 5.0

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

การใช้

delayWithSeconds(1) {
   //Do something
}

Apple มีตัวอย่างของdispatch_afterสำหรับObjective-C :

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(<#delayInSeconds#> * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    <#code to be executed after a specified delay#>
});

นี่เป็นข้อมูลโค้ดเดียวกันที่ส่งไปยังSwift 3:

DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + <#delayInSeconds#>) {
  <#code to be executed after a specified delay#>
}

วิธีอื่นคือขยาย Double ดังนี้:

extension Double {
   var dispatchTime: dispatch_time_t {
       get {
           return dispatch_time(DISPATCH_TIME_NOW,Int64(self * Double(NSEC_PER_SEC)))
       }
   }
}

จากนั้นคุณสามารถใช้สิ่งนี้:

dispatch_after(Double(2.0).dispatchTime, dispatch_get_main_queue(), { () -> Void in
            self.dismissViewControllerAnimated(true, completion: nil)
    })

ฉันชอบฟังก์ชั่นการล่าช้าของแมตต์ แต่ไม่ชอบฉันควร จำกัด การปิดผ่าน

ใน Swift 3.0

ส่งคิว

  DispatchQueue(label: "test").async {
        //long running Background Task
        for obj in 0...1000 {
            print("async \(obj)")
        }

        // UI update in main queue
        DispatchQueue.main.async(execute: { 
            print("UI update on main queue")
        })

    }

    DispatchQueue(label: "m").sync {
        //long running Background Task
        for obj in 0...1000 {
            print("sync \(obj)")
        }

        // UI update in main queue
        DispatchQueue.main.sync(execute: {
            print("UI update on main queue")
        })
    }

ส่งหลังจาก 5 วินาที

    DispatchQueue.main.after(when: DispatchTime.now() + 5) {
        print("Dispatch after 5 sec")
    }

รุ่น Swift 3.0

ฟังก์ชั่นปิดหลังจากทำงานบางอย่างหลังจากความล่าช้าในเธรดหลัก

func performAfterDelay(delay : Double, onCompletion: @escaping() -> Void){

    DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + delay, execute: {
       onCompletion()
    })
}

เรียกใช้ฟังก์ชันนี้เช่น:

performAfterDelay(delay: 4.0) {
  print("test")
}

1) เพิ่มวิธีนี้เป็นส่วนหนึ่งของ UIViewController Extension

extension UIViewController{
func runAfterDelay(delay: NSTimeInterval, block: dispatch_block_t) {
        let time = dispatch_time(DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC)))
        dispatch_after(time, dispatch_get_main_queue(), block)
    }
}

เรียกวิธีนี้ใน VC:

    self.runAfterDelay(5.0, block: {
     //Add code to this block
        print("run After Delay Success")
    })

2)

performSelector("yourMethod Name", withObject: nil, afterDelay: 1)

3)

override func viewWillAppear(animated: Bool) {

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 2), dispatch_get_main_queue(), { () -> () in
    //Code Here
})

// รูปแบบกะทัดรัด

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 2), dispatch_get_main_queue()) {
    //Code here
 }
}

แม้ว่าจะไม่ใช่คำถามดั้งเดิมของ OP แต่NSTimerคำถามที่เกี่ยวข้องบางข้อได้รับการทำเครื่องหมายว่าซ้ำซ้อนกับคำถามนี้ดังนั้นจึงคุ้มค่าที่จะรวมNSTimerคำตอบที่นี่

NSTimer VS dispatch_after

• NSTimerอยู่ในระดับสูงมากขึ้นในขณะที่dispatch_afterอยู่ในระดับต่ำ
• NSTimerง่ายต่อการยกเลิก ยกเลิกdispatch_afterต้องเขียนโค้ดเพิ่มเติม

เลื่อนงานด้วย NSTimer

สร้างNSTimerตัวอย่าง

var timer = NSTimer()

เริ่มจับเวลาด้วยความล่าช้าที่คุณต้องการ

// invalidate the timer if there is any chance that it could have been called before
timer.invalidate()
// delay of 2 seconds
timer = NSTimer.scheduledTimerWithTimeInterval(2.0, target: self, selector: #selector(delayedAction), userInfo: nil, repeats: false) 

เพิ่มฟังก์ชั่นที่จะเรียกหลังจากการหน่วงเวลา (ใช้ชื่อใดก็ตามที่คุณใช้สำหรับselectorพารามิเตอร์ด้านบน)

func delayedAction() {
    print("Delayed action has now started."
}

หมายเหตุ

• timer.invalidate()หากคุณจำเป็นต้องยกเลิกการดำเนินการก่อนที่มันจะเกิดขึ้นเพียงโทร
• repeats: trueสำหรับการใช้งานการกระทำซ้ำแล้วซ้ำอีก

• หากคุณมีเหตุการณ์ครั้งเดียวโดยไม่จำเป็นต้องยกเลิกดังนั้นไม่จำเป็นต้องสร้างtimerตัวแปรอินสแตนซ์ สิ่งต่อไปนี้จะพอเพียง:

  NSTimer.scheduledTimerWithTimeInterval(2.0, target: self, selector: #selector(delayedAction), userInfo: nil, repeats: false) 

• ดูคำตอบที่ฟูลเลอร์ของฉันที่นี่

สำหรับฟังก์ชั่นหลายอย่างใช้สิ่งนี้ สิ่งนี้มีประโยชน์มากในการใช้ภาพเคลื่อนไหวหรือตัวโหลดกิจกรรมสำหรับฟังก์ชั่นสแตติกหรือ UI Update ใด ๆ

DispatchQueue.main.asyncAfter(deadline: .now() + 0.9) {
            // Call your function 1
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                // Call your function 2
            }
        }

ตัวอย่างเช่น - ใช้ภาพเคลื่อนไหวก่อนที่ tableView reloads หรืออัปเดต UI อื่น ๆ หลังจากภาพเคลื่อนไหว

*// Start your amination* 
self.startAnimation()
DispatchQueue.main.asyncAfter(deadline: .now() + 0.9) {
                *// The animation will execute depending on the delay time*
                self.stopAnimation()
                DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                    *// Now update your view*
                     self.fetchData()
                     self.updateUI()
                }
            }

สิ่งนี้ใช้ได้สำหรับฉัน

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

Objective-C:

CGFloat time1 = 3.49;
CGFloat time2 = 8.13;

// Delay 2 seconds

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    CGFloat newTime = time1 + time2;
    NSLog(@"New time: %f", newTime);
});

สวิฟท์ 3 และ 4:

คุณสามารถสร้างส่วนขยายบน DispatchQueue และเพิ่มความล่าช้าของฟังก์ชันซึ่งใช้ DispatchQueue asyncAfter ฟังก์ชันภายใน

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

ใช้:

DispatchQueue.delay(.seconds(1)) {
    print("This is after delay")
}

ผู้ช่วยอีกคนที่จะหน่วงเวลารหัสของคุณที่มีการใช้งานอย่างรวดเร็ว 100%และอนุญาตให้เลือกหัวข้อที่แตกต่างเพื่อเรียกใช้รหัสล่าช้าของคุณจาก:

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

หากคุณต้องการหน่วงเวลารหัสของคุณไปยังเธรดอื่น :

delay(bySeconds: 1.5, dispatchLevel: .background) { 
    // delayed code that will run on background thread
}

ถ้าคุณชอบกรอบที่ยังมีคุณสมบัติที่มีประโยชน์มากขึ้นบางแล้วเช็คเอาท์HandySwift คุณสามารถเพิ่มลงในโครงการของคุณผ่านทาง Carthageจากนั้นใช้อย่างตรงตามตัวอย่างด้านบนเช่น:

import HandySwift    

delay(bySeconds: 1.5) { 
    // delayed code
}

ฉันชอบใช้ส่วนขยายแทนฟังก์ชั่นฟรีเสมอ

สวิฟท์ 4

public extension DispatchQueue {

  private class func delay(delay: TimeInterval, closure: @escaping () -> Void) {
    let when = DispatchTime.now() + delay
    DispatchQueue.main.asyncAfter(deadline: when, execute: closure)
  }

  class func performAction(after seconds: TimeInterval, callBack: @escaping (() -> Void) ) {
    DispatchQueue.delay(delay: seconds) {
      callBack()
    }
  }

}

ใช้ดังต่อไปนี้

DispatchQueue.performAction(after: 0.3) {
  // Code Here
}

ชะลอการโทร GCD โดยใช้ asyncAfter อย่างรวดเร็ว

let delayQueue = DispatchQueue(label: "com.theappmaker.in", qos: .userInitiated)
let additionalTime: DispatchTimeInterval = .seconds(2)

เราสามารถหน่วงเวลาเป็น ** microseconds , milliseconds , nanoseconds

delayQueue.asyncAfter(deadline: .now() + 0.60) {
    print(Date())
}

delayQueue.asyncAfter(deadline: .now() + additionalTime) {
    print(Date())
}

ในSwift 4

ใช้ตัวอย่างนี้:

    let delayInSec = 1.0
    DispatchQueue.main.asyncAfter(deadline: .now() + delayInSec) {
       // code here
       print("It works")
    }

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(10 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    // ...
});

dispatch_after(_:_:_:)ฟังก์ชั่นใช้เวลาสามพารามิเตอร์:

ความล่าช้า
คิวส่ง
บล็อกหรือปิด

dispatch_after(_:_:_:)ฟังก์ชั่นเรียกบล็อกหรือปิดในคิวการจัดส่งที่ถูกส่งผ่านไปยังฟังก์ชันหลังจากที่ล่าช้าได้รับ โปรดทราบว่าความล่าช้าถูกสร้างขึ้นโดยใช้dispatch_time(_:_:)ฟังก์ชั่น จดจำสิ่งนี้เพราะเราใช้ฟังก์ชั่นนี้ใน Swift ด้วย

ผมแนะนำให้ไปผ่านการกวดวิชากวดวิชาRaywenderlich ส่ง

ใน Swift 5 ใช้ในด้านล่าง:

 DispatchQueue.main.asyncAfter(deadline: .now() + 0.2, execute: closure) 

// time gap, specify unit is second
DispatchQueue.main.asyncAfter(deadline: .now() + .seconds(2)) {
            Singleton.shared().printDate()
        }
// default time gap is second, you can reduce it
    DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
          // just do it!
    }

ใช้รหัสนี้เพื่อทำงานบางอย่างที่เกี่ยวข้องกับ UI หลังจาก 2.0 วินาที

            let delay = 2.0
            let delayInNanoSeconds = dispatch_time(DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC)))
            let mainQueue = dispatch_get_main_queue()

            dispatch_after(delayInNanoSeconds, mainQueue, {

                print("Some UI related task after delay")
            })

รุ่น Swift 3.0

ฟังก์ชั่นปิดหลังจากทำงานบางอย่างหลังจากความล่าช้าในเธรดหลัก

func performAfterDelay(delay : Double, onCompletion: @escaping() -> Void){

    DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + delay, execute: {
       onCompletion()
    })
}

เรียกใช้ฟังก์ชันนี้เช่น:

performAfterDelay(delay: 4.0) {
  print("test")
}

ตอนนี้เป็นมากกว่าน้ำตาลซินแทคติกสำหรับการแจกจ่ายแบบอะซิงโครนัสใน Grand Central Dispatch (GCD) ใน Swift

เพิ่ม Podfile

pod 'AsyncSwift'

จากนั้นคุณสามารถใช้มันได้เช่นนี้

let seconds = 3.0
Async.main(after: seconds) {
print("Is called after 3 seconds")
}.background(after: 6.0) {
print("At least 3.0 seconds after previous block, and 6.0 after Async code is called")
}

Swift 4 มีวิธีสั้น ๆ ในการทำสิ่งนี้:

Timer.scheduledTimer(withTimeInterval: 2, repeats: false) { (timer) in
    // Your stuff here
    print("hello")
}

นี่คือ asyncAfter รุ่นในแบบซิงโครนัสใน Swift:

let deadline = DispatchTime.now() + .seconds(3)
let semaphore = DispatchSemaphore.init(value: 0)
DispatchQueue.global().asyncAfter(deadline: deadline) {
    dispatchPrecondition(condition: .onQueue(DispatchQueue.global()))
    semaphore.signal()
}

semaphore.wait()

พร้อมกับอะซิงโครนัสหนึ่ง:

let deadline = DispatchTime.now() + .seconds(3)
DispatchQueue.main.asyncAfter(deadline: deadline) {
    dispatchPrecondition(condition: .onQueue(DispatchQueue.global()))
}