La concurrence sans crainte

Gérer la programmation concurrente de manière sûre et efficace est un autre des objectifs majeurs de Rust. La programmation concurrente, dans laquelle différentes parties d’un programme s’exécutent indépendamment, et la programmation parallèle, dans laquelle différentes parties d’un programme s’exécutent en même temps, deviennent de plus en plus importantes à mesure que les ordinateurs tirent parti de leurs multiples processeurs. Historiquement, programmer dans ces contextes a été difficile et source d’erreurs. Rust espère changer cela.

Au départ, l’équipe Rust pensait que garantir la sécurité de la mémoire et prévenir les problèmes de concurrence étaient deux défis distincts à résoudre avec des méthodes différentes. Au fil du temps, l’équipe a découvert que les systèmes de possession et de types constituent un ensemble d’outils puissants pour gérer la sécurité de la mémoire et les problèmes de concurrence ! En tirant parti de la possession et de la vérification de types, de nombreuses erreurs de concurrence sont des erreurs de compilation en Rust plutôt que des erreurs d’exécution. Par conséquent, plutôt que de vous faire passer beaucoup de temps à essayer de reproduire les circonstances exactes dans lesquelles un bogue de concurrence à l’exécution se produit, le code incorrect refusera de compiler et présentera une erreur expliquant le problème. En conséquence, vous pouvez corriger votre code pendant que vous travaillez dessus plutôt que potentiellement après qu’il a été déployé en production. Nous avons surnommé cet aspect de Rust la concurrence sans crainte (fearless concurrency). La concurrence sans crainte vous permet d’écrire du code exempt de bogues subtils et facile à refactoriser sans introduire de nouveaux bogues.

Remarque : par souci de simplicité, nous désignerons bon nombre de problèmes comme concurrents plutôt que d’être plus précis en disant concurrents et/ou parallèles. Pour ce chapitre, veuillez mentalement substituer concurrent et/ou parallèle chaque fois que nous utilisons concurrent. Dans le chapitre suivant, où la distinction est plus importante, nous serons plus précis.

De nombreux langages sont dogmatiques quant aux solutions qu’ils proposent pour gérer les problèmes de concurrence. Par exemple, Erlang dispose de fonctionnalités élégantes pour la concurrence par passage de messages mais n’offre que des moyens obscurs de partager l’état entre les threads. Ne supporter qu’un sous-ensemble de solutions possibles est une stratégie raisonnable pour les langages de haut niveau car un langage de haut niveau promet des avantages en abandonnant un certain contrôle pour gagner en abstraction. Cependant, les langages de bas niveau sont censés fournir la solution offrant les meilleures performances dans n’importe quelle situation et disposent de moins d’abstractions par rapport au matériel. Par conséquent, Rust offre une variété d’outils pour modéliser les problèmes de la manière la plus appropriée à votre situation et vos besoins.

Voici les sujets que nous aborderons dans ce chapitre :

• Comment créer des threads pour exécuter plusieurs morceaux de code en même temps
• La concurrence par passage de messages, où des canaux envoient des messages entre les threads
• La concurrence par état partagé, où plusieurs threads ont accès à une même donnée
• Les traits Sync et Send, qui étendent les garanties de concurrence de Rust aux types définis par l’utilisateur ainsi qu’aux types fournis par la bibliothèque standard