Cómo crear cola de envío en Swift 3

En Swift 2, pude crear una cola con el siguiente código:

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

Pero esto no se comstack en Swift 3.

¿Cuál es la forma preferida de escribir esto en Swift 3?

Creando una cola concurrente

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

Crea una cola en serie

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

Obtener la cola principal de forma asincrónica

 DispatchQueue.main.async { } 

Obtener la cola principal sincrónicamente

 DispatchQueue.main.sync { } 

Para obtener uno de los hilos de fondo

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

Xcode 8.2 beta 2:

Para obtener uno de los hilos de fondo

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

Si quieres aprender a usar estas colas, mira esta respuesta

Comstack bajo Swift 3 . Este ejemplo contiene la mayor parte de la syntax que necesitamos.

QoS: nueva syntax de calidad de servicio

weak self : para interrumpir los ciclos de retención

si el yo no está disponible, no hagas nada

async global background queue – para consulta de red

async main queue – para tocar la interfaz de usuario.

Por supuesto, debe agregar una verificación de errores a esto …

 DispatchQueue.global(qos: .background).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 } } } } 

Comstackdo en 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() } } } } 

Hice esto y esto es especialmente importante si desea actualizar su UI para mostrar datos nuevos sin que el usuario lo note en UITableView o UIPickerView.

  DispatchQueue.main.async { /*Write your thread code here*/ } 
  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 

He vuelto a trabajar tu código en Xcode 8, Swift 3 y los cambios están marcados en contraste con tu versión de Swift 2.

  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 } 

// use Operation Queue si necesita rellenar los objetos (labels, imageview, textview) en su viewcontroller

Dado que la pregunta de OP ya ha sido respondida anteriormente, solo quiero agregar algunas consideraciones de velocidad:

Hace una gran diferencia qué clase de prioridad le asigna a su función asíncrona en DispatchQueue.global .

No recomiendo ejecutar tareas con la prioridad de subproceso .background, especialmente en el iPhone X, donde la tarea parece estar asignada en los núcleos de baja potencia.

Aquí hay algunos datos reales de una función computacionalmente intensiva que lee desde un archivo XML (con almacenamiento en búfer) y realiza la interpolación de datos:

Nombre del 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

Tenga en cuenta que el conjunto de datos no es el mismo para todos los dispositivos. Es el más grande en el iPhone X y el más pequeño en el iPhone 5s.

Swift 3

desea llamar a un cierre en el código rápido, entonces desea cambiar en el guión gráfico, ya que cualquier tipo de cambio no incluido para ver su aplicación se bloqueará

pero desea utilizar el método de envío, su aplicación no se bloqueará

método asincrónico

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

método de sincronización

 DispatchQueue.main.sync { //Write code here } 
 DispatchQueue.main.async(execute: { // write code }) 

Cola en serie:

 let serial = DispatchQueue(label: "Queuename") serial.sync { //Code Here } 

Cola concurrente:

  let concurrent = DispatchQueue(label: "Queuename", attributes: .concurrent) concurrent.sync { //Code Here } 

Para Swift 3

  DispatchQueue.main.async { // Write your code here } 
  let newQueue = DispatchQueue(label: "newname") newQueue.sync { // your code } 

ahora es simplemente:

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

el valor predeterminado es serial, para obtener concurrente, usa el argumento opcional de atributos .concurrent

Puede crear cola de despacho usando este código en 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*/ } 
 DispatchQueue.main.async(execute: { // code })