Utiliser le MPSC Rust

1. Types de canaux
2. Étapes à suivre pour utiliser Rust MPSC

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:

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.