Comment créer une file d'attente de répartition dans Swift 3

Dans Swift 2, j'ai pu créer une file d'attente avec le code suivant:

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

Mais cela ne se compile pas dans Swift 3.

Quelle est la meilleure façon d'écrire ceci dans Swift 3?

Création d'une file d'attente simultanée

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

}  

Créer une file d'attente série

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

}

Obtenir la file d'attente principale de manière asynchrone

DispatchQueue.main.async {

}

Obtenir la file d'attente principale de manière synchrone

DispatchQueue.main.sync {

}

Pour obtenir l'un des fils d'arrière-plan

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

}

Xcode 8.2 beta 2:

Pour obtenir l'un des fils d'arrière-plan

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

}

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

Si vous souhaitez en savoir plus sur l'utilisation de ces files d'attente .Voir cette réponse

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

QoS - nouvelle syntaxe de qualité de service

weak self - perturber les cycles de rétention

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

async global utility queue- pour la requête réseau, n'attend pas le résultat, c'est une file d'attente simultanée, le bloc (généralement) n'attend pas au démarrage. L'exception pour une file d'attente simultanée peut être, lorsque sa limite de tâches a été précédemment atteinte, puis la file d'attente se transforme temporairement en file d'attente série et attend jusqu'à ce qu'une tâche précédente dans cette file d'attente se termine.

async main queue- pour toucher l'interface utilisateur, le bloc n'attend pas le résultat, mais attend son emplacement au départ. La file d'attente principale est une file d'attente série.

Bien sûr, vous devez ajouter une vérification d'erreur à cela ...

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

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

        }
    }

}

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 affectez à votre fonction asynchrone dans DispatchQueue.global .

Je ne recommande pas d'exécuter des tâches avec la priorité de thread .background, en particulier sur l'iPhone X où la tâche semble être allouée sur les cœurs de faible puissance.

Voici quelques données réelles d'une fonction de calcul intensif qui lit à partir d'un fichier XML (avec mise en mémoire tampon) et effectue une interpolation des données:

Nom du périphérique / .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,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 grand sur l'iPhone X et le plus petit sur l'iPhone 5s.

J'ai fait cela et cela est particulièrement important si vous souhaitez actualiser votre interface utilisateur pour afficher de nouvelles données sans que l'utilisateur ne s'en rende compte comme dans UITableView ou 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
}

// utilisez Operation Queue si vous devez remplir les objets (labels, imageview, textview) sur votre 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

J'ai retravaillé votre code dans Xcode 8, Swift 3 et les changements sont marqués contrairement à votre version Swift 2.

Swift 3

vous voulez appeler une fermeture en code rapide puis vous voulez changer dans le storyboard ya tout type de changement appartient pour voir votre application va planter

mais vous souhaitez utiliser la méthode de répartition, votre application ne se bloquera pas

méthode asynchrone

DispatchQueue.main.async 
{
 //Write code here                                   

}

méthode de synchronisation

DispatchQueue.main.sync 
{
     //Write code here                                  

}

DispatchQueue.main.async(execute: {

// write code

})

File d'attente série:

let serial = DispatchQueue(label: "Queuename")

serial.sync { 

 //Code Here

}

File d'attente simultanée:

 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

 }

Mise à jour pour Swift 5

File d'attente série

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

File d'attente simultanée

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

concurrentQueue.async {
// code to execute
}

De la documentation Apple :

Paramètres

étiquette

Une étiquette de chaîne à attacher à la file d'attente pour l'identifier de manière unique dans les outils de débogage tels que les instruments, les échantillons, les photos de pile et les rapports de plantage. Étant donné que les applications, les bibliothèques et les frameworks peuvent tous créer leurs propres files d'attente de répartition, un style de dénomination DNS inversé (com.example.myqueue) est recommandé. Ce paramètre est facultatif et peut être NULL.

qos

Niveau de qualité de service à associer à la file d'attente. Cette valeur détermine la priorité à laquelle le système planifie les tâches à exécuter. Pour une liste des valeurs possibles, voir DispatchQoS.QoSClass.

les attributs

Les attributs à associer à la file d'attente. Incluez l'attribut concurrent pour créer une file d'attente de répartition qui exécute les tâches simultanément. Si vous omettez cet attribut, la file d'attente de répartition exécute les tâches en série.

autoreleaseFrequency

Fréquence de libération automatique des objets créés par les blocs que la file d'attente planifie. Pour une liste des valeurs possibles, voir DispatchQueue.AutoreleaseFrequency .

cible

La file d'attente cible sur laquelle exécuter les blocs. Spécifiez DISPATCH_TARGET_QUEUE_DEFAULT si vous souhaitez que le système fournisse une file d'attente appropriée pour l'objet actuel.

c'est maintenant simplement:

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

la valeur par défaut est série, pour obtenir simultanément, vous utilisez l'argument facultatif des attributs .concurrent

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

Vous pouvez créer une file d'attente de répartition à l'aide de 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*/
}