doc:4.6:threads-qtconcurrent [Projets de traduction de la rubrique Qt]

- Programmation concurrente
  - Introduction
  - Remerciements
Discussion

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() applique une fonction à tous les éléments d’un conteneur, modifiant ainsi les éléments en place ;
QtConcurrent::mapped() est similaire à map(), sauf qu’elle retourne un nouveau conteneur avec les modifications ;
QtConcurrent::mappedReduced() est similaire à mapped(), sauf que les modifications sont réduites à un seul résultat ;
QtConcurrent::filter() retire tous les éléments d’un conteneur à partir du résultat d’une fonction de filtrage ;
QtConcurrent::filtered() est similaire à filter(), sauf qu’elle retourne un nouveau conteneur avec les éléments résultants du filtrage ;
QtConcurrent::filteredReduced() est similaire à filtered(), sauf que les éléments résultant du filtrage sont réduits à un seul résultat ;
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() et 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 !