===== Programmation concurrente =====

Le namespace [[QtConcurrent]] fournit des API de haut niveau qui offrent la possibilité d'écrire des programmes multi-thread sans l'aide de primitives de bas niveau liées aux threads telles que les mutex, les verrous de lecture-écriture, les attentes de conditions ou les sémaphores.

==== Introduction ====

Les programmes écrits avec [[QtConcurrent]] ajustent automatiquement le nombre de threads utilisés en fonction du nombre de coeurs processeurs disponibles. Cela signifie que les applications écrites aujourd'hui continueront d'évoluer lors du déploiement sur des systèmes multi-coeurs dans le futur.

[[QtConcurrent]] inclut des API de modèle de programmation fonctionnelle pour le traitement de liste parallèle, incluant une implémentation de MapReduce et de FilterReduce pour des systèmes de partage-mémoire (non distribuée), et des classes permettant de contrôler des calculs asynchrones dans des applications GUI :

    * [[qtconcurrent#map|QtConcurrent::map()]] applique une fonction à tous les éléments d'un conteneur, modifiant ainsi les éléments en place ; 
    * [[qtconcurrent#mapped|QtConcurrent::mapped()]] est similaire à map(), sauf qu'elle retourne un nouveau conteneur avec les modifications ; 
    * [[qtconcurrent#mappedReduced|QtConcurrent::mappedReduced()]] est similaire à mapped(), sauf que les modifications sont réduites à un seul résultat ; 
    * [[qtconcurrent#filter|QtConcurrent::filter()]] retire tous les éléments d'un conteneur à partir du résultat d'une fonction de filtrage ; 
    * [[qtconcurrent#filtered|QtConcurrent::filtered()]] est similaire à filter(), sauf qu'elle retourne un nouveau conteneur avec les éléments résultants du filtrage ; 
    * [[qtconcurrent#filteredReduced|QtConcurrent::filteredReduced()]] est similaire à filtered(), sauf que les éléments résultant du filtrage sont réduits à un seul résultat ; 
    * [[qtconcurrent#run|QtConcurrent::run()]] exécute une fonction dans un autre thread ; 
    * [[QFuture]] représente le résultat d'un calcul asynchrone ; 
    * [[QFutureIterator]] permet l'itération des résultats disponibles via [[QFuture]] ; 
    * [[QFutureWatcher]] permet le suivi de [[QFuture]] en utilisant les signaux et les slots ; 
    * [[QFutureSynchronizer]] est une classe outil qui synchronise automatiquement plusieurs [[QFuture]].

Qt Concurrent prend en charge plusieurs conteneurs et types d'itérateurs STL-compatibles, mais fonctionne mieux avec les conteneurs Qt qui ont des itérateurs d'accès aléatoire, tels que [[QList]] ou [[QVector]]. Les fonctions de mappage et de filtrage acceptent toutes les deux les conteneurs et les itérateurs de début/fin.

Vue d'ensemble des itérateurs STL pris en charge :

^ Type d'itérateur ^ Classes d'exemple ^ Statut de prise en charge^
| Input Iterator         | | Non pris en charge |
| Output Iterator        | | Non pris en charge |
| Forward Iterator       | ''std::slist'' | Pris en charge |
| Bidirectional Iterator | [[QLinkedList]], ''std::list'' | Pris en charge | 
| Random Access Iterator | [[QList]], [[QVector]], ''std::vector'' | Pris en charge et recommandés | 

Les itérateurs d'accès aléatoire peuvent être plus rapides dans les cas où Qt Concurrent itére un grand nombre d'éléments légers, étant donné qu'elle permet d'aller à n'importe quel emplacement dans le conteneur. De plus, utiliser les itérateurs d'accès aléatoire permet à Qt Concurrent de fournir des informations sur la progression à travers les fonctions [[qfuture#progressValue|QFuture::progressValue()]] et [[QFutureWatcher#progressValueChanged|QFutureWatcher::progressValueChanged()]].

Les fonctions de modifications qui n'écrasent pas les données telles que mapped() et filtered() effectuent une copie du conteneur lorsqu'elles sont appelées. Si vous utilisez des conteneurs STL, cette opération de copie peut prendre un certain temps ; dans ce cas, nous recommandons de spécifier l'itérateur de début et de fin du conteneur.

==== Remerciements ====

Merci à <!xhell!> et à <!johnlamericain!> pour leur traduction ainsi qu'à <!hornetbzz!> et à <!dourouc!> pour la relecture !