So erstellen Sie eine Versandwarteschlange in Swift 3

In Swift 2 konnte ich eine Warteschlange mit folgendem Code erstellen:

let concurrentQueue = dispatch_queue_create("com.swift3.imageQueue", DISPATCH_QUEUE_CONCURRENT)

Dies wird jedoch in Swift 3 nicht kompiliert.

Was ist die bevorzugte Methode, um dies in Swift 3 zu schreiben?

Erstellen einer gleichzeitigen Warteschlange

let concurrentQueue = DispatchQueue(label: "queuename", attributes: .concurrent)
concurrentQueue.sync {

}  

Erstellen Sie eine serielle Warteschlange

let serialQueue = DispatchQueue(label: "queuename")
serialQueue.sync { 

}

Hauptwarteschlange asynchron abrufen

DispatchQueue.main.async {

}

Hauptwarteschlange synchron abrufen

DispatchQueue.main.sync {

}

Um einen der Hintergrund-Threads zu erhalten

DispatchQueue.global(qos: .background).async {

}

Xcode 8.2 Beta 2:

Um einen der Hintergrund-Threads zu erhalten

DispatchQueue.global(qos: .default).async {

}

DispatchQueue.global().async {
    // qos' default value is ´DispatchQoS.QoSClass.default`
}

Wenn Sie mehr über die Verwendung dieser Warteschlangen erfahren möchten, lesen Sie diese Antwort

Kompiliert unter> = Swift 3 . Dieses Beispiel enthält den größten Teil der Syntax, die wir benötigen.

QoS - neue Syntax für Servicequalität

weak self - Haltezyklen zu unterbrechen

Wenn Selbst nicht verfügbar ist, tun Sie nichts

async global utility queue- Bei Netzwerkabfragen wird nicht auf das Ergebnis gewartet, es handelt sich um eine gleichzeitige Warteschlange. Der Block wartet (normalerweise) nicht beim Start. Eine Ausnahme für eine gleichzeitige Warteschlange könnte sein, dass die Warteschlange, wenn ihr Aufgabenlimit zuvor erreicht wurde, vorübergehend in eine serielle Warteschlange umgewandelt wird und wartet, bis eine vorherige Aufgabe in dieser Warteschlange abgeschlossen ist.

async main queue- Zum Berühren der Benutzeroberfläche wartet der Block nicht auf das Ergebnis, sondern zu Beginn auf seinen Steckplatz. Die Hauptwarteschlange ist eine serielle Warteschlange.

Natürlich müssen Sie hier einige Fehlerprüfungen hinzufügen ...

DispatchQueue.global(qos: .utility).async { [weak self] () -> Void in

    guard let strongSelf = self else { return }

    strongSelf.flickrPhoto.loadLargeImage { loadedFlickrPhoto, error in

        if error != nil {
            print("error:\(error)")
        } else {
            DispatchQueue.main.async { () -> Void in
                activityIndicator.removeFromSuperview()
                strongSelf.imageView.image = strongSelf.flickrPhoto.largeImage
            }
        }
    }
}

Kompiliert in XCode 8, Swift 3 https://github.com/rpthomas/Jedisware

 @IBAction func tap(_ sender: AnyObject) {

    let thisEmail = "emailaddress.com"
    let thisPassword = "myPassword" 

    DispatchQueue.global(qos: .background).async {

        // Validate user input

        let result = self.validate(thisEmail, password: thisPassword)

        // Go back to the main thread to update the UI
        DispatchQueue.main.async {
            if !result
            {
                self.displayFailureAlert()
            }

        }
    }

}

Da die OP-Frage bereits oben beantwortet wurde, möchte ich nur einige Überlegungen zur Geschwindigkeit hinzufügen:

Es macht einen großen Unterschied, welche Prioritätsklasse Sie Ihrer asynchronen Funktion in DispatchQueue.global zuweisen .

Ich empfehle nicht, Aufgaben mit der Priorität .background thread auszuführen, insbesondere auf dem iPhone X, wo die Aufgabe auf den Kernen mit geringem Stromverbrauch zugewiesen zu sein scheint.

Hier sind einige reale Daten aus einer rechenintensiven Funktion, die aus einer XML-Datei (mit Pufferung) liest 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,3s / 6,1s / 4,0s / 4,0s / 3,8s

Beachten Sie, dass der Datensatz nicht für alle Geräte gleich ist. Es ist das größte auf dem iPhone X und das kleinste auf dem iPhone 5s.

Ich habe dies getan und dies ist besonders wichtig, wenn Sie Ihre Benutzeroberfläche aktualisieren möchten, um neue Daten anzuzeigen, ohne dass der Benutzer dies wie in UITableView oder UIPickerView bemerkt.

    DispatchQueue.main.async
 {
   /*Write your thread code here*/
 }

 DispatchQueue.main.async {
          self.collectionView?.reloadData() // Depends if you were populating a collection view or table view
    }


OperationQueue.main.addOperation {
    self.lblGenre.text = self.movGenre
}

// Verwenden Sie die Operationswarteschlange, wenn Sie die Objekte (Beschriftungen, Bildansicht, Textansicht) auf Ihrem Viewcontroller füllen müssen

   let concurrentQueue = dispatch_queue_create("com.swift3.imageQueue", DISPATCH_QUEUE_CONCURRENT) //Swift 2 version

   let concurrentQueue = DispatchQueue(label:"com.swift3.imageQueue", attributes: .concurrent) //Swift 3 version

Ich habe Ihren Code in Xcode 8, Swift 3 überarbeitet und die Änderungen sind im Gegensatz zu Ihrer Swift 2-Version markiert.

Swift 3

Wenn Sie einen Abschluss in schnellem Code aufrufen möchten, möchten Sie ihn im Storyboard ändern. Jede Art von Änderung gehört zur Ansicht, dass Ihre Anwendung abstürzt

Wenn Sie jedoch die Versandmethode verwenden möchten, stürzt Ihre Anwendung nicht ab

asynchrone Methode

DispatchQueue.main.async 
{
 //Write code here                                   

}

Synchronisierungsmethode

DispatchQueue.main.sync 
{
     //Write code here                                  

}

DispatchQueue.main.async(execute: {

// write code

})

Serielle Warteschlange:

let serial = DispatchQueue(label: "Queuename")

serial.sync { 

 //Code Here

}

Gleichzeitige Warteschlange:

 let concurrent = DispatchQueue(label: "Queuename", attributes: .concurrent)

concurrent.sync {

 //Code Here
}

Für Swift 3

   DispatchQueue.main.async {
        // Write your code here
    }

 let newQueue = DispatchQueue(label: "newname")
 newQueue.sync { 

 // your code

 }

Update für Swift 5

Serielle Warteschlange

let serialQueue = DispatchQueue.init(label: "serialQueue")
serialQueue.async {
    // code to execute
}

Gleichzeitige Warteschlange

let concurrentQueue = DispatchQueue.init(label: "concurrentQueue", qos: .background, attributes: .concurrent, autoreleaseFrequency: .inherit, target: nil)

concurrentQueue.async {
// code to execute
}

Aus der Apple-Dokumentation :

Parameter

Etikette

Eine Zeichenfolgenbezeichnung, die an die Warteschlange angehängt werden soll, um sie in Debugging-Tools wie Instruments, Sample, Stackshots und Absturzberichten eindeutig zu identifizieren. Da Anwendungen, Bibliotheken und Frameworks ihre eigenen Versandwarteschlangen erstellen können, wird ein Reverse-DNS-Benennungsstil (com.example.myqueue) empfohlen. Dieser Parameter ist optional und kann NULL sein.

qos

Das Quality-of-Service-Level, das der Warteschlange zugeordnet werden soll. Dieser Wert bestimmt die Priorität, mit der das System Aufgaben für die Ausführung plant. Eine Liste möglicher Werte finden Sie unter DispatchQoS.QoSClass.

Attribute

Die Attribute, die der Warteschlange zugeordnet werden sollen. Fügen Sie das Attribut concurrent hinzu, um eine Versandwarteschlange zu erstellen, in der Aufgaben gleichzeitig ausgeführt werden. Wenn Sie dieses Attribut weglassen, führt die Versandwarteschlange Aufgaben seriell aus.

AutoreleaseFrequency

Die Häufigkeit, mit der Objekte, die von den von der Warteschlange geplanten Blöcken erstellt wurden, automatisch freigegeben werden. Eine Liste möglicher Werte finden Sie unter DispatchQueue.AutoreleaseFrequency .

Ziel

Die Zielwarteschlange, in der Blöcke ausgeführt werden sollen. Geben Sie DISPATCH_TARGET_QUEUE_DEFAULT an, wenn das System eine Warteschlange bereitstellen soll, die für das aktuelle Objekt geeignet ist.

es ist jetzt einfach:

let serialQueue = DispatchQueue(label: "my serial queue")

Der Standardwert ist seriell. Um gleichzeitig zu werden, verwenden Sie das optionale Attributargument .concurrent

DispatchQueue.main.async(execute: {
   // code
})

Mit diesem Code können Sie in Swift 3.0 eine Versandwarteschlange erstellen

DispatchQueue.main.async
 {
   /*Write your code here*/
 }

   /* or */

let delayTime = DispatchTime.now() + Double(Int64(0.5 * Double(NSEC_PER_SEC))) / Double(NSEC_PER_SEC)                   
DispatchQueue.main.asyncAfter(deadline: delayTime)
{
  /*Write your code here*/
}