Dispatch_after - GCD in Swift? dispatch_after - GCD in Swift?

Question

Ich habe das iBook von Apple durchgesehen und konnte keine Definition davon finden:

Kann jemand die Struktur von dispatch_after erklären?

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

Answer 1

Ich ziehe es immer vor, Erweiterungen anstelle von kostenlosen Funktionen zu verwenden.

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

}

Verwende es folgendermaßen.

DispatchQueue.performAction(after: 0.3) {
  // Hier Code einfügen
}

Answer 2

Verzögerung des GCD-Aufrufs mit asyncAfter in Swift

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

Wir können die Verzögerung als **Mikrosekunden,Millisekunden,Nanosekunden angeben

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

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

Answer 3

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

Die Funktion dispatch_after(_:_:_:) hat drei Parameter:

eine Verzögerung
eine Dispatch-Warteschlange
ein Block oder Closure

Die Funktion dispatch_after(_:_:_:) ruft den Block oder die Closure in der übergebenen Dispatch-Warteschlange nach einer bestimmten Verzögerung auf. Beachten Sie, dass die Verzögerung mit der Funktion dispatch_time(_:_:) erstellt wird. Merken Sie sich das, denn diese Funktion wird auch in Swift verwendet.

Ich empfehle, das Tutorial Raywenderlich Dispatch tutorial durchzugehen

Answer 4

Ein weiterer Helfer, um Ihren Code zu verzögern, der zu 100% Swift in der Verwendung ist und optional ermöglicht, einen anderen Thread zu wählen, um Ihren verzögerten Code auszuführen:

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

Jetzt verzögern Sie einfach Ihren Code auf dem Hauptthread, so wie dies:

delay(bySeconds: 1.5) { 
    // verzögerter Code
}

Wenn Sie Ihren Code auf einem anderen Thread verzögern möchten:

delay(bySeconds: 1.5, dispatchLevel: .background) { 
    // verzögerter Code, der auf einem Hintergrundthread ausgeführt wird
}

---

Wenn Sie ein Framework bevorzugen, das auch einige praktische Funktionen bietet, dann schauen Sie sich HandySwift an. Sie können es zu Ihrem Projekt hinzufügen über Carthage und es dann genau wie in den obigen Beispielen verwenden, z.B.:

import HandySwift    

delay(bySeconds: 1.5) { 
    // verzögerter Code
}

Answer 5

In Swift 4

Verwenden Sie diesen Snippet:

    let VerzögerungInSeconds = 1.0
    DispatchQueue.main.asyncAfter(deadline: .now() + VerzögerungInSeconds) {
       // code hier
       print("Es funktioniert")
    }