Wie verwende ich einen Hintergrund-Thread in Swift?

Question

Wie verwendet man Threading in Swift?

dispatchOnMainThread:^{

    NSLog(@"Block wird auf %s ausgeführt", dispatch_queue_get_label(dispatch_get_current_queue()));

}];

Answer 1

Von Jameson Quave's Tutorial

Swift 2

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), {
    //All stuff here
})

Answer 2

Swift 5

Um es einfach zu machen, erstellen Sie eine Datei "DispatchQueue+Extensions.swift" mit diesem Inhalt:

import Foundation

typealias Dispatch = DispatchQueue

extension Dispatch {

    static func background(_ task: @escaping () -> ()) {
        Dispatch.global(qos: .background).async {
            task()
        }
    }

    static func main(_ task: @escaping () -> ()) {
        Dispatch.main.async {
            task()
        }
    }
}

Verwendung:

Dispatch.background {
    // do stuff

    Dispatch.main { 
        // update UI
    }
}

Answer 3

Swift 4.x

Fügen Sie dies in eine Datei ein:

func background(work: @escaping () -> ()) {
    DispatchQueue.global(qos: .userInitiated).async {
        work()
    }
}

func main(work: @escaping () -> ()) {
    DispatchQueue.main.async {
        work()
    }
}

und rufen Sie es dort auf, wo Sie es benötigen:

background {
     //Hintergrundjob
     main {
       //UI aktualisieren (oder was Sie im Hauptthread tun müssen)
     }
}

Answer 4

Du musst die Änderungen, die du im Hintergrund ausführen möchtest, von den Aktualisierungen trennen, die du auf der Benutzeroberfläche ausführen möchtest:

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) {
    // Führe deine Aufgabe aus

    dispatch_async(dispatch_get_main_queue()) {
        // Aktualisiere einige UI-Elemente
    }
}

Answer 5

Gute Antworten trotzdem, jedenfalls möchte ich meine objektorientierte Lösung Aktuell für Swift 5 teilen.

Schau es dir bitte an: AsyncTask

Konzeptuell inspiriert von Android's AsyncTask, habe ich meine eigene Klasse in Swift geschrieben

AsyncTask ermöglicht eine ordnungsgemäße und einfache Verwendung des UI-Threads. Diese Klasse ermöglicht das Ausführen von Hintergrundoperationen und das Veröffentlichen von Ergebnissen im UI-Thread.

Hier sind ein paar Beispiele für die Verwendung

Beispiel 1 -

AsyncTask(backgroundTask: {(p:String)->Void in//setze BGParam auf String und BGResult auf Void
        print(p);//drucke den Wert im Hintergrundthread
    }).execute("Hallo async");//mit dem Wert 'Hallo async' ausführen

Beispiel 2 -

let task2=AsyncTask(beforeTask: {
           print("Vor der Ausführung");//drucke 'Vor der Ausführung' vor backgroundTask
        },backgroundTask:{(p:Int)->String in//setze BGParam auf Int & BGResult auf String
            if p>0{//überprüfen, ob Ausführungswert größer als null ist
               return "positiv"//String "positiv" an afterTask übergeben
            }
            return "negativ";//ansonsten String "negativ" übergeben
        }, afterTask: {(p:String) in
            print(p);//Hintergrundtaskergebnis drucken
    });
    task2.execute(1);//mit Wert 1 ausführen

Es hat 2 generische Typen:

• BGParam - der Typ des Parameters, der bei der Ausführung an die Aufgabe gesendet wird.

• BGResult - der Typ des Ergebnisses der Hintergrundberechnung.

  Wenn Sie ein AsyncTask erstellen, können Sie diese Typen auf das passen, was Sie für den Ein- und Ausgang der Hintergrundaufgabe benötigen, aber wenn Sie diese Typen nicht benötigen, können Sie sie als unbenutzt kennzeichnen, indem Sie sie einfach auf: Void oder mit einer kürzeren Syntax: () setzen

Wenn eine asynchrone Aufgabe ausgeführt wird, durchläuft sie 3 Schritte:

1. beforeTask:()->Void auf dem UI-Thread aufgerufen kurz bevor die Aufgabe ausgeführt wird.
2. backgroundTask: (param:BGParam)->BGResult auf dem Hintergrundthread unmittelbar danach aufgerufen
3. afterTask:(param:BGResult)->Void auf dem UI-Thread aufgerufen mit dem Ergebnis aus der Hintergrundaufgabe