ios - snippet - wordpress title tag plugin




Wie benutzt man Hintergrundthread in swift? (6)

Schnelle 3 Version

Swift 3 verwendet die neue DispatchQueue Klasse zum Verwalten von Warteschlangen und Threads. Um etwas auf dem Hintergrund-Thread auszuführen, würden Sie Folgendes verwenden:

let backgroundQueue = DispatchQueue(label: "com.app.queue", qos: .background)
backgroundQueue.async {
    print("Run on background thread")
}

Oder wenn Sie etwas in zwei Codezeilen möchten:

DispatchQueue.global(qos: .background).async {
    print("Run on background thread")

    DispatchQueue.main.async {
        print("We finished that.")
        // only back on the main thread, may you access UI:
        label.text = "Done."
    }
}

In diesem Tutorial können Sie auch detaillierte Informationen über GDC in Swift 3 erhalten.

Wie verwende ich Threading in swift?

dispatchOnMainThread:^{

    NSLog(@"Block Executed On %s", dispatch_queue_get_label(dispatch_get_current_queue()));

}];

Swift 3.0+

In Swift 3.0 wurde viel modernized . Das Ausführen von etwas im Hintergrund-Thread sieht folgendermaßen aus:

DispatchQueue.global(qos: .background).async {
    print("This is run on the background queue")

    DispatchQueue.main.async {
        print("This is run on the main queue, after the previous code in outer block")
    }
}

Swift 1.2 bis 2.3

let qualityOfServiceClass = QOS_CLASS_BACKGROUND
let backgroundQueue = dispatch_get_global_queue(qualityOfServiceClass, 0)
dispatch_async(backgroundQueue, {
    print("This is run on the background queue")

    dispatch_async(dispatch_get_main_queue(), { () -> Void in
        print("This is run on the main queue, after the previous code in outer block")
    })
})

Pre Swift 1.2 - Bekanntes Problem

Ab Swift 1.1 unterstützte Apple die obige Syntax nicht ohne einige Modifikationen. Das Übergeben von QOS_CLASS_BACKGROUND funktionierte nicht wirklich, stattdessen verwenden Sie Int(QOS_CLASS_BACKGROUND.value) .

Weitere Informationen finden Sie in der Apple-Dokumentation


Dan Beaulieus Antwort in swift3.

Schnell 3.0.1

extension DispatchQueue {

    static func background(delay: Double = 0.0, background: (()->Void)? = nil, completion: (() -> Void)? = nil) {
        DispatchQueue.global(qos: .background).async {
            background?()
            if let completion = completion {
                DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: {
                    completion()
                })
            }
        }
    }

}

Verwendung

DispatchQueue.background(delay: 3.0, background: {
    // do something in background
}, completion: {
    // when background job finishes, wait 3 seconds and do something in main thread
})

DispatchQueue.background(background: {
    // do something in background
}, completion:{
    // when background job finished, do something in main thread
})

DispatchQueue.background(delay: 3.0, completion:{
    // do something in main thread after 3 seconds
})

Die beste Vorgehensweise besteht darin, eine wiederverwendbare Funktion zu definieren, auf die mehrere Male zugegriffen werden kann.

WIEDERVERWENDBARE FUNKTION:

zB irgendwo wie AppDelegate.swift als globale Funktion.

func backgroundThread(delay: Double = 0.0, background: (() -> Void)? = nil, completion: (() -> Void)? = nil) {
    dispatch_async(dispatch_get_global_queue(Int(QOS_CLASS_USER_INITIATED.value), 0)) {
        if(background != nil){ background!(); }

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

Hinweis: Ersetzen Sie in Swift 2.0 QOS_CLASS_USER_INITIATED.value stattdessen durch QOS_CLASS_USER_INITIATED.rawValue

VERWENDUNG:

A. Um einen Prozess im Hintergrund mit einer Verzögerung von 3 Sekunden auszuführen:

    backgroundThread(3.0, background: {
            // Your background function here
    })

B. Um einen Prozess im Hintergrund auszuführen, führen Sie einen Abschluss im Vordergrund aus:

    backgroundThread(background: {
            // Your function here to run in the background
    },
    completion: {
            // A function to run in the foreground when the background thread is complete
    })

C. Um 3 Sekunden zu verzögern - beachten Sie die Verwendung des Abschlussparameters ohne Hintergrundparameter:

    backgroundThread(3.0, completion: {
            // Your delayed function here to be run in the foreground
    })

Ich mag die Antwort von Dan Beaulieu wirklich, aber es funktioniert nicht mit Swift 2.2 und ich denke, wir können diese fiesen Zwangsauszüge 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()
            }
        }
    }
}

Sie müssen die Änderungen, die Sie im Hintergrund ausführen möchten, von den Aktualisierungen trennen, die auf der Benutzeroberfläche ausgeführt werden sollen:

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) {
    // do your task

    dispatch_async(dispatch_get_main_queue()) {
        // update some UI
    }
}




swift