Rust asynchrone Kanäle-Kommunikation

RustRustBeginner
Jetzt üben

This tutorial is from open-source community. Access the source code

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab werden Sie über Rusts asynchrone Kanäle lernen, die eine einseitige Kommunikation zwischen Threads über die Sender- und Receiver-Endpunkte ermöglichen, wie im bereitgestellten Rust-Codesnippet gezeigt.

Hinweis: Wenn im Lab kein Dateiname angegeben ist, können Sie einen beliebigen Dateinamen verwenden. Beispielsweise können Sie main.rs verwenden und es mit rustc main.rs &&./main kompilieren und ausführen.

Kanäle

Rust bietet asynchrone Kanäle für die Kommunikation zwischen Threads. Kanäle ermöglichen einen einseitigen Informationsfluss zwischen zwei Endpunkten: dem Sender und dem Receiver.

use std::sync::mpsc::{Sender, Receiver};
use std::sync::mpsc;
use std::thread;

static NTHREADS: i32 = 3;

fn main() {
    // Kanäle haben zwei Endpunkte: den `Sender<T>` und den `Receiver<T>`,
    // wobei `T` der Typ der zu übertragenden Nachricht ist
    // (die Typangabe ist überflüssig)
    let (tx, rx): (Sender<i32>, Receiver<i32>) = mpsc::channel();
    let mut children = Vec::new();

    for id in 0..NTHREADS {
        // Der Sender-Endpunkt kann kopiert werden
        let thread_tx = tx.clone();

        // Jeder Thread wird seine ID über den Kanal senden
        let child = thread::spawn(move || {
            // Der Thread erhält die Eigentumsgewalt über `thread_tx`
            // Jeder Thread stellt eine Nachricht in den Kanal ein
            thread_tx.send(id).unwrap();

            // Senden ist eine nicht blockierende Operation, der Thread wird sofort fortfahren
            // nachdem er seine Nachricht gesendet hat
            println!("thread {} finished", id);
        });

        children.push(child);
    }

    // Hier werden alle Nachrichten gesammelt
    let mut ids = Vec::with_capacity(NTHREADS as usize);
    for _ in 0..NTHREADS {
        // Die `recv`-Methode wählt eine Nachricht aus dem Kanal aus
        // `recv` wird den aktuellen Thread blockieren, wenn keine Nachrichten verfügbar sind
        ids.push(rx.recv());
    }

    // Warte, bis die Threads alle verbleibende Arbeit beendet haben
    for child in children {
        child.join().expect("oops! the child thread panicked");
    }

    // Zeige die Reihenfolge, in der die Nachrichten gesendet wurden
    println!("{:?}", ids);
}

Zusammenfassung

Herzlichen Glückwunsch! Sie haben das Channels-Lab abgeschlossen. Sie können in LabEx weitere Labs absolvieren, um Ihre Fähigkeiten zu verbessern.