C++11 et les normes suivantes ont introduit une nouvelle bibliothèque de threads. Cette bibliothèque inclut des utilitaires pour démarrer et gérer les threads. Elle fournit aussi des primitives de synchronisation comme les mutex et autres verrous, ainsi que des variables atomiques et les utilitaires associés.
Disposer d'une façon standard de gérer la concurrence en C++ est une amélioration majeure. Avant l'introduction de ces fonctionnalités, les projets C++ s'appuyaient sur diverses bibliothèques et approches pour gérer la concurrence.
Dans cet article, nous allons voir les avantages de la lecture du livre «Concurrency with Modern C++» écrit par Rainer Grimm.
Une approche pragmatique
En informatique, certains livres sont avant tout académiques et destinés aux étudiants, tandis que d'autres sont écrits pour les développeurs qui ont besoin de conseils pratiques pour résoudre des problèmes concrets lors de la construction d'un produit. Ce livre suit une approche pragmatique, et dès le début il référence le package d'exemples et explique comment les compiler. L'objectif est de pratiquer chaque solution proposée dans le livre.
La vue d'ensemble dès le début
En général, on peut se faire une idée du contenu d'un livre en regardant la table des matières et en lisant l'introduction. Cependant, dans de nombreux cas, cela ne suffit pas vraiment pour avoir une idée claire des objectifs du livre.
Ce qui est intéressant avec ce livre, c'est qu'il comporte une section « Quick Overview » de 8 pages qui explique clairement le problème, les solutions et les fonctionnalités que les nouvelles normes apportent.
Le modèle mémoire expliqué clairement
Dès le Quick Overview, les contraintes du modèle mémoire sont clairement expliquées.
Le fondement du multithreading est un modèle mémoire bien défini. Ce modèle mémoire doit traiter les aspects suivants : • Les opérations atomiques : des opérations qui peuvent être effectuées sans interruption. • L'ordonnancement partiel des opérations : une séquence d'opérations qui ne doit pas être réordonnée. • Les effets visibles des opérations : la garantie du moment où les opérations sur des variables partagées sont visibles dans les autres threads.
Et dans la section dédiée au modèle mémoire, l'auteur fournit une analyse approfondie des contraintes mémoire, accompagnée de nombreux exemples de code qui facilitent la compréhension de la gestion de la mémoire dans les scénarios concurrents. Plus utiles encore sont les illustrations utilisées pour expliquer les problèmes et leurs solutions.
Cette section présente aussi les fonctionnalités fournies par les normes plus récentes pour gérer la mémoire dans les programmes concurrents.
Le multithreading démystifié
Trop de programmeurs qui écrivent des programmes multithread apprennent à créer une poignée de threads et à les faire fonctionner à peu près, mais ensuite les threads échappent complètement à tout contrôle et le programmeur ne sait plus quoi faire. Après cela, corriger un bug ou ajouter du code devient un casse-tête. Parfois, corriger un bug peut en introduire beaucoup d'autres.
Il est donc conseillé de maîtriser les bases du multithreading avant de l'utiliser dans du code de production. Heureusement, le C++ dispose d'une interface de multithreading depuis C++11, et cette interface possède tous les blocs de base pour créer des programmes multithread. Il est préférable d'avoir une façon standard de traiter les threads.
Un point fort de la section Multithreading du livre est son approche pas à pas, qui la rend utile même pour les débutants qui ne sont pas encore familiers avec les threads. Je recommanderais aussi cette section aux développeurs C++ expérimentés. Personnellement, même après avoir travaillé avec les threads pendant de nombreuses années, j'y ai découvert plusieurs détails intéressants et de nouvelles fonctionnalités.
Comme dans la section sur le modèle mémoire, de nombreux exemples de code et illustrations rendent les concepts du multithreading plus faciles à comprendre.
Des études de cas pour pratiquer la théorie
Après avoir présenté la théorie sur le modèle mémoire et l'interface de multithreading, l'auteur l'applique en pratique et vous fournit quelques chiffres de performance.
Les études de cas sont faciles à suivre, comme celle sur le calcul de la somme d'un vecteur. L'auteur explique aussi en profondeur les différentes options d'implémentation disponibles avec les fonctionnalités du C++ moderne.
Après avoir lu et pratiqué la première étude de cas, vous aurez une compréhension pratique de nombreux problèmes de concurrence et de la façon de les résoudre. Je recommande cette étude de cas à tout développeur qui veut maîtriser la concurrence en C++.
Des défis et des bonnes pratiques à la fin
Après avoir couvert le modèle mémoire et le multithreading, et les avoir consolidés à travers des études de cas, l'auteur propose plusieurs défis intéressants. Voici sa motivation pour les inclure :
Programmer de manière concurrente est intrinsèquement compliqué. Cela est particulièrement vrai si vous utilisez les fonctionnalités de C++11 et C++14. Je n'ai même pas encore parlé du modèle mémoire. Mon espoir est qu'en consacrant un chapitre entier aux défis de la programmation concurrente, vous deveniez plus conscients des pièges.
L'auteur fournit aussi plusieurs bonnes pratiques pour gérer la concurrence, comme il l'explique :
Ce chapitre vous fournit un ensemble simple de règles pour écrire des programmes concurrents bien définis et rapides en C++ moderne. Le multithreading, et en particulier le parallélisme et la concurrence, est un sujet assez nouveau en C++ ; par conséquent, de plus en plus de bonnes pratiques seront découvertes dans les années à venir. Considérez les règles de ce chapitre non pas comme une liste complète, mais plutôt comme un point de départ nécessaire qui évoluera au fil du temps.
Conclusion
En lisant le livre, il devient clair que l'auteur est un programmeur avec une longue expérience de la résolution de problèmes réels dans des projets C++, ce qui explique l'approche pragmatique du livre. Nous recommandons ce livre à tout développeur qui veut maîtriser la concurrence en C++ moderne.