Rust Multi-Sender, Single-Receiver Communication

Last update on December 21 2024 10:19:00 (UTC/GMT +8 hours)

Write a Rust program that creates multiple sender threads and a single receiver thread. Each sender thread sends a message through the channel, and the receiver thread prints the messages.

Sample Solution:

Rust Code:

use std::sync::mpsc;
use std::thread;

const NUM_SENDERS: usize = 3;
const NUM_MESSAGES_PER_SENDER: usize = 5;

fn main() {
    // Create a channel for communication between sender and receiver threads
    let (sender, receiver) = mpsc::channel();

    // Spawn sender threads
    for i in 0..NUM_SENDERS {
        let sender_clone = sender.clone(); // Clone sender for each thread
        thread::spawn(move || {
            // Send messages from each sender thread
            for j in 0..NUM_MESSAGES_PER_SENDER {
                let message = format!("Sender {} Message {}", i + 1, j + 1);
                sender_clone.send(message).expect("Failed to send message");
            }
        });
    }

    // Spawn receiver thread
    thread::spawn(move || {
        // Receive and print messages from all sender threads
        for received in receiver {
            println!("Received: {}", received);
        }
    });

    // Wait for all threads to finish
    thread::sleep(std::time::Duration::from_secs(1));
}

Output:

Explanation:

In the exercise above,

Imports and Constants:

Import necessary modules from the standard library, including std::sync::mpsc for creating channels and std::thread for handling threads.
Constants 'NUM_SENDERS' and 'NUM_MESSAGES_PER_SENDER' define the number of sender threads to spawn and the number of messages each sender will send, respectively.

Main Function:

Inside the "main()" function, a channel is created using mpsc::channel(). This channel will be used for communication between sender and receiver threads.

Sender Threads:

A loop spawns multiple sender threads. For each sender thread:

A clone of the sender endpoint is created using "sender.clone()". This ensures that each sender thread has its own sender.
A new thread is spawned, and within its closure, it sends a fixed number of messages through the channel using 'sender_clone.send(message)'.

Receiver Thread:

Another thread is spawned to act as a receiver. Inside its closure, it continuously receives messages from the channel using a loop and prints each received message to the console.

Thread Synchronization:

To ensure that the main thread does not exit before all other threads complete their execution, a brief pause is introduced using thread::sleep(std::time::Duration::from_secs(1)).

Execution Flow:

The sender threads run concurrently, sending messages through the channel.
The receiver thread also runs concurrently, continuously receiving and printing messages from the channel.
Once all threads complete their tasks, the program exits.

Rust Code Editor:

Previous: Rust Multi-Message Channel Communication.
Next: Rust Producer-Consumer Pattern with Channels.