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

Da die Eingangsfrage bereits beantwortet wurde, möchte ich nur einige Geschwindigkeitsüberlegungen hinzufügen:

Ich empfehle nicht, Aufgaben mit der .background-Threadpriorität auszuführen, insbesondere nicht auf dem iPhone X, wo die Aufgabe anscheinend auf den schwachen Kernen zugewiesen wird.

Hier sind einige Echtzeitdaten einer rechenintensiven Funktion, die aus einer XML-Datei liest (mit Pufferung) und Dateninterpolation durchführt:

Gerätename / .background / .utility / .default / .userInitiated / .userInteractive

1. iPhone X: 18,7 s / 6,3 s / 1,8 s / 1,8 s / 1,8 s
2. iPhone 7: 4,6 s / 3,1 s / 3,0 s / 2,8 s / 2,6 s
3. iPhone 5s: 7,3 s / 6,1 s / 4,0 s / 4,0 s / 3,8 s

Beachten Sie, dass der Datensatz nicht für alle Geräte gleich ist. Er ist am größten auf dem iPhone X und am kleinsten auf dem iPhone 5s.

Answer 2

Zweckmäßige Funktion für Threads

public enum QueueType {
        case Main
        case Background
        case LowPriority
        case HighPriority

        var queue: DispatchQueue {
            switch self {
            case .Main:
                return DispatchQueue.main
            case .Background:
                return DispatchQueue(label: "com.app.queue",
                                     qos: .background,
                                     target: nil)
            case .LowPriority:
                return DispatchQueue.global(qos: .userInitiated)
            case .HighPriority:
                return DispatchQueue.global(qos: .userInitiated)
            }
        }
    }

    func performOn(_ queueType: QueueType, closure: @escaping () -> Void) {
        queueType.queue.async(execute: closure)
    }

Verwendung:

performOn(.Background) {
    //Code
}

Answer 3

Ich mag die Antwort von Dan Beaulieu wirklich gerne, aber sie funktioniert nicht mit Swift 2.2 und ich denke, wir können diese lästigen erzwungenen Entpackungen vermeiden!

func backgroundThread(delay: Double = 0.0, background: (() -> Void)? = nil, completion: (() -> Void)? = nil) {

    dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0)) {

        background?()

        if let completion = completion{
            let popTime = dispatch_time(DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC)))
            dispatch_after(popTime, dispatch_get_main_queue()) {
                completion()
            }
        }
    }
}

Answer 4

Grand Central Dispatch wird verwendet, um Multitasking in unseren iOS-Apps zu behandeln.

Sie können diesen Code verwenden

// Verwendung von Zeitintervallen

DispatchQueue.main.asyncAfter(deadline: DispatchTime.now()+1) {
    print("Hallo Welt")
}

// Hintergrundthread
queue.sync {
     for i in 0..<10 {
          print("Hallo", i)
     }
}

// Hauptthread
for i in 20..<30 {
     print("Hallo", i)
}

Weitere Informationen finden Sie unter diesem Link: https://www.programminghub.us/2018/07/integrate-dispatcher-in-swift.html

Answer 5

Gibt es einen Nachteil (wenn Sie anschließend einen Vordergrundbildschirm starten müssen) des unten stehenden Codes?

import Foundation
import UIKit

class TestTimeDelay {

    static var verbunden:Bool = false

    static var zaehler:Int = 0

    static func showAfterDelayControl(uiViewController:UIViewController) {
        NSLog("TestTimeDelay", "showAfterDelayControl")
    }

    static func tryReconnect() -> Bool {
        zaehler += 1
        NSLog("TestTimeDelay", "Zähler:\(zaehler)")
        return zaehler > 4
    }

    static func waitOnConnectWithDelay(milliseconds:Int, uiViewController: UIViewController) {

        DispatchQueue.global(qos: .background).async {
            DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + DispatchTimeInterval.milliseconds(milliseconds), execute: {
                waitOnConnect(uiViewController: uiViewController)
            })
        }
    }

    static func waitOnConnect(uiViewController:UIViewController) {

        verbunden = tryReconnect()
        if verbunden {
            showAfterDelayControl(uiViewController: uiViewController)
        }
        else {
            waitOnConnectWithDelay(milliseconds: 200, uiViewController:uiViewController)
        }
     }
}