Come creare la coda di invio in Swift 3

In Swift 2, sono stato in grado di creare una coda con il seguente codice:

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

Ma questo non si compila in Swift 3.

Qual è il modo preferito di scrivere questo in Swift 3?

Creazione di una coda simultanea

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

}  

Crea una coda seriale

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

}

Ottieni la coda principale in modo asincrono

DispatchQueue.main.async {

}

Ottieni la coda principale in modo sincrono

DispatchQueue.main.sync {

}

Per ottenere uno dei thread in background

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

}

Xcode 8.2 beta 2:

Per ottenere uno dei thread in background

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

}

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

Se vuoi imparare a usare queste code. Vedi questa risposta

Compila sotto> = Swift 3 . Questo esempio contiene la maggior parte della sintassi di cui abbiamo bisogno.

QoS: nuova sintassi della qualità del servizio

weak self - interrompere i cicli di mantenimento

se il sé non è disponibile, non fare nulla

async global utility queue- per query di rete, non attende il risultato, è una coda simultanea, il blocco (di solito) non attende all'avvio. Un'eccezione per una coda concorrente potrebbe essere, quando il limite di attività è stato precedentemente raggiunto, quindi la coda si trasforma temporaneamente in una coda seriale e attende fino al completamento di alcune attività precedenti in quella coda.

async main queue- per toccare l'interfaccia utente, il blocco non attende il risultato, ma attende il suo slot all'inizio. La coda principale è una coda seriale.

Ovviamente, devi aggiungere un po 'di controllo degli errori a questo ...

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
            }
        }
    }
}

Compilato 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()
            }

        }
    }

}

Poiché alla domanda OP è già stata data una risposta sopra, voglio solo aggiungere alcune considerazioni sulla velocità:

Fa molta differenza quale classe di priorità assegni alla tua funzione asincrona in DispatchQueue.global .

Non consiglio di eseguire attività con .background priorità del thread particolare su iPhone X in cui l'attività sembra essere allocata sui core a bassa potenza.

Ecco alcuni dati reali da una funzione ad alta intensità computazionale che legge da un file XML (con buffering) ed esegue l'interpolazione dei dati:

Nome dispositivo / .background / .utility / .default / .userInitiated / .userInteractive

1. iPhone X: 18.7s / 6.3s / 1.8s / 1.8s / 1.8s
2. iPhone 7: 4.6s / 3.1s / 3.0s / 2.8s / 2.6s
3. iPhone 5s: 7.3s / 6.1s / 4.0s / 4.0s / 3.8s

Si noti che il set di dati non è lo stesso per tutti i dispositivi. È il più grande su iPhone X e il più piccolo su iPhone 5s.

L'ho fatto e questo è particolarmente importante se si desidera aggiornare l'interfaccia utente per mostrare nuovi dati senza che l'utente se ne accorga come in UITableView o UIPickerView.

    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
}

// usa la coda operazioni se devi popolare gli oggetti (etichette, visualizzazione immagine, visualizzazione testo) sul tuo viewcontroller

   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

Ho rielaborato il tuo codice in Xcode 8, Swift 3 e le modifiche sono contrassegnate in contrasto con la tua versione di Swift 2.

Swift 3

vuoi chiamare un po 'di chiusura nel codice rapido quindi vuoi cambiare nello storyboard ya qualsiasi tipo di modifica offri per vedere la tua applicazione andrà in crash

ma si desidera utilizzare il metodo di invio dell'applicazione non si arresta in modo anomalo

metodo asincrono

DispatchQueue.main.async 
{
 //Write code here                                   

}

metodo di sincronizzazione

DispatchQueue.main.sync 
{
     //Write code here                                  

}

DispatchQueue.main.async(execute: {

// write code

})

Coda seriale:

let serial = DispatchQueue(label: "Queuename")

serial.sync { 

 //Code Here

}

Coda concorrente:

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

concurrent.sync {

 //Code Here
}

Per Swift 3

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

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

 // your code

 }

Aggiornamento per swift 5

Coda seriale

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

Coda simultanea

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

concurrentQueue.async {
// code to execute
}

Dalla documentazione Apple :

parametri

etichetta

Un'etichetta di stringa da allegare alla coda per identificarla in modo univoco in strumenti di debug come strumenti, campioni, stackshots e rapporti sugli arresti anomali. Poiché le applicazioni, le librerie e i framework possono tutti creare le proprie code di invio, si consiglia uno stile di denominazione DNS inverso (com.example.myqueue). Questo parametro è facoltativo e può essere NULL.

QoS

Il livello di qualità del servizio da associare alla coda. Questo valore determina la priorità con cui il sistema pianifica le attività per l'esecuzione. Per un elenco di possibili valori, vedere DispatchQoS.QoSClass.

attributi

Gli attributi da associare alla coda. Includere l'attributo simultaneo per creare una coda di invio che esegue attività contemporaneamente. Se si omette tale attributo, la coda di invio esegue le attività in serie.

autoreleaseFrequency

La frequenza con cui rilasciare automaticamente gli oggetti creati dai blocchi pianificati dalla coda. Per un elenco di possibili valori, vedere DispatchQueue.AutoreleaseFrequency .

bersaglio

La coda di destinazione su cui eseguire i blocchi. Specificare DISPATCH_TARGET_QUEUE_DEFAULT se si desidera che il sistema fornisca una coda appropriata per l'oggetto corrente.

ora è semplicemente:

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

il valore predefinito è seriale, per essere simultanei, si utilizza l'argomento degli attributi facoltativi .concurrent

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

Puoi creare una coda di invio usando questo codice in swift 3.0

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*/
}