Comment créer une file D'attente d'envoi dans Swift 3

Compile sous "151950920 Swift" 3 . Cet exemple contient la plupart de la syntaxe dont nous avons besoin.

QoS - nouvelle qualité de service de la syntaxe

weak self - perturber les cycles de rétention

si l'auto n'est pas disponible, ne rien faire

async global background queue - pour le réseau de la requête

async main queue - pour toucher L'UI.

bien sûr, vous devez ajouter quelques la vérification d'erreur...

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

compilé dans 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()
            }

        }
    }

}

j'ai fait cela et c'est particulièrement important si vous voulez rafraîchir votre UI pour afficher de nouvelles données sans que l'utilisateur s'en aperçoive, comme dans Uitablview ou UIPickerView.

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

puisque la question OP a déjà été répondue ci-dessus, je veux juste ajouter quelques considérations de vitesse:

Cela fait beaucoup de différence quelle classe de priorité vous assignez à votre fonction async dans DispatchQueue.mondial .

Je ne recommande pas d'exécuter des tâches avec le .background priorité de fil particulièrement sur l'iPhone X où la tâche semble être attribuée sur les noyaux de faible puissance.

voici quelques données réelles d'une fonction de calcul intensif qui lit à partir d'un fichier XML (avec buffering) et effectue l'interpolation de données:

nom du dispositif / .arrière-plan / .utilité / .par défaut / .userInitiated / .useinteractif

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

notez que l'ensemble de données n'est pas le même pour tous les appareils. C'est le plus gros sur l'iPhone X et le plus petit sur l'iPhone 5s.

   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

j'ai retravaillé votre code dans Xcode 8, Swift 3 et les changements sont marqués en contraste avec votre version 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
}

/ / utiliser la file D'attente D'opération si vous avez besoin de peupler les objets(étiquettes, imageview, textview) sur votre viewcontroller

Swift 3

vous voulez appeler une certaine fermeture en code swift puis vous voulez changer en storyboard ya n'importe quel changement de type off appartient à voir votre application va planter

mais vous voulez utiliser la méthode de régulation de vol votre application ne s'écrasera pas

méthode async

DispatchQueue.main.async 
{
 //Write code here                                   

}

méthode de synchronisation

DispatchQueue.main.sync 
{
     //Write code here                                  

}

DispatchQueue.main.async(execute: {

// write code

})

De Série De La File D'Attente :

let serial = DispatchQueue(label: "Queuename")

serial.sync { 

 //Code Here

}

file D'attente concurrente:

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

concurrent.sync {

 //Code Here
}

Pour Swift 3

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

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

 // your code

 }

il est tout simplement:

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

la valeur par défaut est serial, pour obtenir concurrent, vous utilisez l'argument optionnel attributes .concurrent

vous pouvez créer une file d'attente d'expédition en utilisant ce code dans 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
})