Gleichzeitige vs serielle Warteschlangen in GCD

Hier sind ein paar Experimente, die ich getan habe, um mich zu verstehen, über diese serial, concurrent Warteschlangen mit Grand Central Dispatch.

 func doLongAsyncTaskInSerialQueue() {

   let serialQueue = DispatchQueue(label: "com.queue.Serial")
      for i in 1...5 {
        serialQueue.async {

            if Thread.isMainThread{
                print("task running in main thread")
            }else{
                print("task running in background thread")
            }
            let imgURL = URL(string: "https://upload.wikimedia.org/wikipedia/commons/0/07/Huge_ball_at_Vilnius_center.jpg")!
            let _ = try! Data(contentsOf: imgURL)
            print("\(i) completed downloading")
        }
    }
}

Aufgabe ausgeführt wird, im anderen thread(andere als main-thread) bei Verwendung von async in den GCD. Async execute next line nicht warten, bis der block führt die Ergebnisse non-blocking main thread & main queue.
Seit seiner seriellen queue, alle ausgeführt in der Reihenfolge, wie Sie Hinzugefügt werden serielle queue.Aufgaben nacheinander ausgeführt werden immer nacheinander ausgeführt, indem die einzigen thread, die der Warteschlange zugeordnet.

func doLongSyncTaskInSerialQueue() {
    let serialQueue = DispatchQueue(label: "com.queue.Serial")
    for i in 1...5 {
        serialQueue.sync {
            if Thread.isMainThread{
                print("task running in main thread")
            }else{
                print("task running in background thread")
            }
            let imgURL = URL(string: "https://upload.wikimedia.org/wikipedia/commons/0/07/Huge_ball_at_Vilnius_center.jpg")!
            let _ = try! Data(contentsOf: imgURL)
            print("\(i) completed downloading")
        }
    }
}

Task kann die Ausführung im Haupt-thread, wenn Sie sync verwenden, die in den GCD. Sync läuft ein block auf eine Warteschlange und wartet, bis es zu vervollständigen, die Ergebnisse in die Sperrung Haupt-thread oder Haupt-Warteschlange.Da die Haupt-Warteschlange-muss warten, bis die ausgelöst block vervollständigt, Haupt-thread zum verarbeiten Blöcke von queues anderer als der Haupt-queue.Daher gibt es eine chance, den code ausführen auf dem hintergrund der Warteschlange kann tatsächlich die Ausführung im Haupt-thread
Seit seiner seriellen queue, alle ausgeführt in der Reihenfolge in der Sie Hinzugefügt werden(FIFO).

func doLongASyncTaskInConcurrentQueue() {
    let concurrentQueue = DispatchQueue(label: "com.queue.Concurrent", attributes: .concurrent)
    for i in 1...5 {
        concurrentQueue.async {
            if Thread.isMainThread{
                print("task running in main thread")
            }else{
                print("task running in background thread")
            }
            let imgURL = URL(string: "https://upload.wikimedia.org/wikipedia/commons/0/07/Huge_ball_at_Vilnius_center.jpg")!
            let _ = try! Data(contentsOf: imgURL)
            print("\(i) completed downloading")
        }
        print("\(i) executing")
    }
}

Aufgabe im hintergrund ausgeführt wird thread, wenn Sie verwenden async in den GCD. Async execute next line nicht warten, bis der block führt die Ergebnisse non-blocking Haupt-thread.
Denken Sie daran, in concurrent queue-task werden in der Reihenfolge verarbeitet, Sie werden zur Warteschlange Hinzugefügt, aber mit verschiedenen Gewinden befestigt
Warteschlange. Denken Sie daran, Sie sollen nicht die Aufgabe zu beenden, als die Bestellung
sind Sie der Warteschlange Hinzugefügt wurden.Um der Aufgabe unterscheidet sich jedes mal
threads erstellt werden, wie unbedingt automatisch.Task-parallel ausgeführt. Mit mehr als
dass(maxConcurrentOperationCount) erreicht wird, einige Aufgaben zu Verhalten
als serielle, bis ein thread frei ist.

func doLongSyncTaskInConcurrentQueue() {
  let concurrentQueue = DispatchQueue(label: "com.queue.Concurrent", attributes: .concurrent)
    for i in 1...5 {
        concurrentQueue.sync {
            if Thread.isMainThread{
                print("task running in main thread")
            }else{
                print("task running in background thread")
            }
            let imgURL = URL(string: "https://upload.wikimedia.org/wikipedia/commons/0/07/Huge_ball_at_Vilnius_center.jpg")!
            let _ = try! Data(contentsOf: imgURL)
            print("\(i) completed downloading")
        }
        print("\(i) executed")
    }
}

Task kann die Ausführung im Haupt-thread, wenn Sie sync verwenden, die in den GCD. Sync läuft ein block auf eine Warteschlange und wartet, bis es zu vervollständigen, die Ergebnisse in die Sperrung Haupt-thread oder Haupt-Warteschlange.Da die Haupt-Warteschlange-muss warten, bis die ausgelöst block vervollständigt, Haupt-thread zum verarbeiten Blöcke von queues anderer als der Haupt-queue.Daher gibt es eine chance, den code ausführen auf dem hintergrund der Warteschlange kann tatsächlich die Ausführung im Haupt-thread.
Seit seiner gleichzeitigen Warteschlange, Aufgaben können nicht zu Ende, in der Reihenfolge, wie Sie sind zur Warteschlange Hinzugefügt. Aber mit synchronen Betrieb tut es, obwohl Sie verarbeitet werden können, die von verschiedenen threads. Also, es verhält sich so, als dieses ist die serielle queue.

Hier ist eine Zusammenfassung dieser Experimente

Erinnere mich, mit GCD Sie sind nur das hinzufügen von tasks an die Warteschlange und darstellende Aufgabe aus der Warteschlange. Die Warteschlange löst Ihre Aufgabe entweder im Haupt-oder hintergrund-thread, je nachdem, ob die operation synchron oder asynchron. Arten von queues Seriell,Parallel,Main dispatch queue.Alle Aufgabe, die Sie ausführen, geschieht durch die Vorgabe von Main dispatch queue.Es gibt bereits vier vordefinierte Globale concurrent queues für Ihre Anwendung zu verwenden und eine Haupt-Warteschlange(DispatchQueue.main).Sie können auch manuell erstellen Sie Ihre eigene Warteschlange und führen Sie die Aufgabe aus der Warteschlange.

UI Related task sollte immer durchgeführt werden, von der main-thread durch die Entsendung der task Main queue.Kurzer hand Dienstprogramm ist DispatchQueue.main.sync/async in der Erwägung, dass-Netzwerk Zusammenhang/schwere Operationen sollte immer durchgeführt werden, asynchron, keine Fragen, denen je ein Faden, den Sie entweder Haupt-oder hintergrund

BEARBEITEN:
Es gibt jedoch Fälle, die Sie durchführen müssen Netzwerk ruft die Operationen synchron in einem hintergrund-thread, ohne zu frieren-UI (- e.g.erfrischend OAuth-Token und warten, ob es gelingt oder nicht).Sie brauchen, um die wrap-Methode, die innerhalb einen asynchronen Betrieb.Auf diese Weise Ihre schwere Operationen in der Reihenfolge ausgeführt werden und ohne Sperrung Haupt-thread.

func doMultipleSyncTaskWithinAsynchronousOperation() {
    let concurrentQueue = DispatchQueue(label: "com.queue.Concurrent", attributes: .concurrent)
    concurrentQueue.async {
        let concurrentQueue = DispatchQueue.global(qos: DispatchQoS.QoSClass.default)
        for i in 1...5 {
            concurrentQueue.sync {
                let imgURL = URL(string: "https://upload.wikimedia.org/wikipedia/commons/0/07/Huge_ball_at_Vilnius_center.jpg")!
                let _ = try! Data(contentsOf: imgURL)
                print("\(i) completed downloading")
            }
            print("\(i) executed")
        }
    }
}

EDIT EDIT: Sie können beobachten Sie das demo-video hier

InformationsquelleAutor der Antwort