Utiliser le MPSC Rust

Muhammad Adil 30 janvier 2023
  1. Types de canaux
  2. Étapes à suivre pour utiliser Rust MPSC
Utiliser le MPSC Rust

Rust possède de nombreuses fonctionnalités qui en font un choix attrayant pour les programmeurs. L’un est la possibilité d’envoyer des messages de différents types sur le même canal.

Cette fonctionnalité permet aux programmeurs Rust d’éviter les courses de données et de contrôler davantage l’utilisation de la mémoire de leur programme. Ce tutoriel sur le canal Rust se concentrera sur l’envoi de différents types en utilisant le même canal.

Le MPSC (producteurs multiples, consommateurs uniques) est un excellent moyen d’envoyer des messages dans un programme Rust. Le MPSC est une file d’attente qui peut être utilisée à la fois pour envoyer et recevoir des messages.

L’envoi de messages dans Rust peut se faire via les canaux disponibles dans le std::sync module. Les canaux fournissent une interface pour envoyer et recevoir des données entre des threads ou des processus sans verrouillage ni synchronisation explicite.

Types de canaux

Deux types de chaînes sont disponibles :

Un canal asynchrone tamponné indéfiniment

Tous les envois seront asynchrones ; par conséquent, la fonction channel renverra un tuple (Sender, Receiver) (ils ne bloquent jamais). Le canal a un tampon sans fin en théorie.

Un canal délimité et synchrone

La méthode du canal de synchronisation renvoie un tuple (SyncSender, Receiver) avec une taille de tampon pré-allouée pour les messages en attente. Toutes les transmissions seront synchrones et bloquées jusqu’à ce qu’il y ait suffisamment d’espace tampon.

Il convient de noter qu’une limite de 0 permet au canal de devenir un canal de rendez-vous, dans lequel chaque expéditeur envoie atomiquement un message à un destinataire.

Étapes à suivre pour utiliser Rust MPSC

Pour utiliser les canaux dans Rust, vous devez importer le crate MPSC. Les étapes sont les suivantes:

  • Importez la caisse en ajoutant cette ligne en haut de votre fichier :
    use mpsc::{Sender, Receiver};
    
  • Créez un nouvel expéditeur et un nouveau destinataire en ajoutant cette ligne après l’importation :
    let (tx, rx) = mpsc::channel();
    
  • Enfin, envoyez des messages sur tx.

Discutons d’un exemple.

use std::sync::mpsc::{self, Receiver, Sender};
enum Furniture {
    Bed(i32),
    Table(i32)
}
fn main() {
    let (tx, rx): (Sender<Furniture>, Receiver<Furniture>) = mpsc::channel();
    tx.send(Furniture::Table(2)).unwrap();
    tx.send(Furniture::Bed(4)).unwrap();
    for _ in 0..2 {
        match rx.recv().unwrap() {
            Furniture::Bed(a) => println!("Got {} Beds", a),
            Furniture::Table(b) => println!("Got {} Tables", b),
        }
    }
}

Production:

Got 2 Tables
Got 4 Beds

Cliquez ici pour vérifier la démonstration du code mentionné ci-dessus.

Muhammad Adil avatar Muhammad Adil avatar

Muhammad Adil is a seasoned programmer and writer who has experience in various fields. He has been programming for over 5 years and have always loved the thrill of solving complex problems. He has skilled in PHP, Python, C++, Java, JavaScript, Ruby on Rails, AngularJS, ReactJS, HTML5 and CSS3. He enjoys putting his experience and knowledge into words.

Facebook