🚧 Attention, peinture fraüche !

Cette page a Ă©tĂ© traduite par une seule personne et n'a pas Ă©tĂ© relue et vĂ©rifiĂ©e par quelqu'un d'autre ! Les informations peuvent par exemple ĂȘtre erronĂ©es, ĂȘtre formulĂ©es maladroitement, ou contenir d'autres types de fautes.

Vous pouvez contribuer à l'amélioration de cette page sur sa Pull Request.

L'Ă©tat de l'art de l'asynchrone en Rust

Certaines parties du Rust asynchrone sont pris en charge avec les mĂȘmes garanties de stabilitĂ© que le Rust synchrone. Les autres parties sont en cours de perfectionnement et Ă©volueront dans le temps. Voici ce que vous pouvez attendre du Rust asynchrone :

  • D'excellentes performances Ă  l'exĂ©cution des charges de travail en concurrence classiques.
  • Une interaction plus rĂ©guliĂšre avec les fonctionnalitĂ©s avancĂ©es du langage, comme les durĂ©es de vie et l'Ă©pinglage.
  • Des contraintes de compatibilitĂ©, Ă  la fois entre le code synchrone et asynchrone, et entre les diffĂ©rents environnements d'exĂ©cution.
  • Une plus grande exigence de maintenance, Ă  cause de l'Ă©volution continue des environnements d'exĂ©cution asynchrones et du langage.

En résumé, le Rust asynchrone est plus difficile à utiliser et peut demander plus de maintenance que le Rust synchrone, mais il vous procure en retour les meilleures performances dans le domaine. Tous les éléments du Rust asynchrone dont en constante amélioration, donc les effets de ces contre-parties s'estomperont avec le temps.

La prise en charge des bibliothĂšques et du langage

Bien que la programmation asynchrone soit fournie par le coeur de Rust, la plupart des applications asynchrones dépendent des fonctionnalités offertes par les crates de la communauté. Par conséquent, vous devez avoir recours à un mélange de fonctionnalités offertes par le langage et les bibliothÚques :

  • Les traits, types et fonctions les plus fondamentaux, comme le trait Future, sont fournis par la bibliothĂšque standard.
  • La syntaxe async/await est prise en charge directement par le compilateur Rust.
  • De nombreux types, macros et fonctions utilitaires sont fournis par la crate futures. Ils peuvent ĂȘtre utilisĂ©s dans de nombreuses applications asynchrones en Rust.
  • L'exĂ©cution du code asynchrone, les entrĂ©es/sorties, et la crĂ©ation de tĂąches sont prises en charge par les "environnements d'exĂ©cution asynchrone", comme Tokio et async-std. La plupart des applications asynchrones, et certaines crates asynchrones, dĂ©pendent d'un environnement d'exĂ©cution prĂ©cis. Vous pouvez consulter la section "L'Ă©cosystĂšme asynchrone" pour en savoir plus.

Certaines fonctionnalitĂ©s du langage auquel vous ĂȘtes habituĂ© en Rust synchrone peuvent ne pas encore ĂȘtre disponible en Rust asynchrone. Par exemple, Rust ne vous permet pas encore de dĂ©clarer des fonctions asynchrones dans des traits. Par consĂ©quent, vous avez besoin de mettre en place des solutions de substitution pour arriver au mĂȘme rĂ©sultat, ce qui peut rendre les choses un peu plus verbeuses.

La compilation et le débogage

Dans la plupart des cas, les erreurs du compilateur et d'exĂ©cution du Rust asynchrone fonctionnent de la mĂȘme maniĂšre qu'elles l'ont toujours fait en Rust. Voici quelques diffĂ©rences intĂ©ressantes :

Les erreurs de compilation

Les erreurs de compilateur en Rust asynchrone suivent les mĂȘmes rĂšgles strictes que le Rust synchrone, mais comme le Rust asynchrone dĂ©pend souvent de fonctionnalitĂ©s du langage plus Ă©laborĂ©es, comme les durĂ©es de vie et l'Ă©pinglage, vous pourriez rencontrer plus rĂ©guliĂšrement ces types d'erreurs.

Les erreurs à l'exécution

A chaque fois que le compilateur va rencontrer une fonction asynchrone, il va gĂ©nĂ©rer une machine Ă  Ă©tats en arriĂšre-plan. Les traces de la pile en Rust asynchrone contiennent gĂ©nĂ©ralement des informations sur ces machines Ă  Ă©tats, ainsi que les appels de fonctions de l'environnement d'exĂ©cution. Par consĂ©quent, l'interprĂ©tation des traces de la pile peut ĂȘtre un peu plus ardue qu'elle le serait en Rust synchrone.

Les nouveaux types d'erreurs

Quelques nouveaux types d'erreurs sont possibles avec Rust asynchrone, par exemple si vous appelez une fonction bloquante Ă  partir d'un contexte asynchrone ou si vous n'implĂ©mentez pas correctement le trait Future. Ces erreurs peuvent ne pas ĂȘtre signalĂ©es par le compilateur et parfois mĂȘme ne peuvent pas ĂȘtre couvertes par vos tests unitaires. Le but de ce livre est de vous apprendre les principes fondamentaux pour vous aider Ă  Ă©viter ces piĂšges.

Remarques à propos de la compatibilité

Le code asynchrone et synchrone ne peuvent pas toujours ĂȘtre combinĂ©s librement. Par exemple, vous ne pouvez pas appeler directement une fonction asynchrone Ă  partir d'une fonction synchrone. Le code synchrone et asynchrone ont aussi tendance Ă  favoriser des motifs de conception diffĂ©rents, ce qui peut rendre difficile de combiner du code destinĂ© aux diffĂ©rents environnements.

Et mĂȘme le code asynchrone ne peut pas ĂȘtre combinĂ© librement. Certaines crates dĂ©pendent d'un environnement d'exĂ©cution asynchrone pour fonctionner. Si c'est le cas, c'est souvent prĂ©cisĂ© dans la liste des dĂ©pendances de la crate.

Ces problĂšmes de compatibilitĂ© peuvent rĂ©duire vos options, donc il vaut mieux faire assez tĂŽt vos recherches sur les environnements d'exĂ©cution asynchrone et de leurs crates associĂ©es. Une fois que vous vous ĂȘtes installĂ© dans un environnement d'exĂ©cution, vous n'aurez plus Ă  vous soucier de la compatibilitĂ©.

Les performances

Les performances du Rust asynchrone dĂ©pend de l'implĂ©mentation de l'environnement d'exĂ©cution asynchrone que vous choisissez. MĂȘme si les environnements d'exĂ©cution qui propulsent les applications asynchrones en Rust sont relativement rĂ©cents, ils sont remarquablement performants pour la plupart des charges de travail.

Ceci Ă©tant dit, la plupart des Ă©cosystĂšmes asynchrones prĂ©voient un environnement d'exĂ©cution multi-processus. Cela rend plus difficile d'apprĂ©cier les bienfaits sur les performances thĂ©oriques des applications asynchrone sur un seul processus, appelĂ©e aussi synchronisation allĂ©gĂ©e. Un autre domaine d'application sous-cĂŽtĂ© est celui des tĂąches sensibles Ă  la latence, qui sont importantes pour les pilotes, les applications avec interface graphique, parmi d'autres. Ces tĂąches dĂ©pendent de l'environnement d'exĂ©cution et/ou de la prise en charge du systĂšme d'exploitation pour ĂȘtre orchestrĂ©es correctement. Vous pouvez donc espĂ©rer une meilleure prise en charge Ă  l'avenir des bibliothĂšques de ces cas d'usages.