Rust MPSC Channels - צ׳אנלים בראסט

use tokio::sync::mpsc;
use tokio::task;

#[tokio::main]
async fn main() {
    let (tx, mut rx) = mpsc::channel(32);

    // Spawn a task that sends messages
    task::spawn(async move {
        for i in 0..10 {
            if tx.send(i).await.is_err() {
                println!("receiver dropped");
                return;
            }
        }
    });

    // Receive messages
    while let Some(val) = rx.recv().await {
        println!("Received: {}", val);
    }
}

use tokio::sync::mpsc;
use tokio::task;
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    let (tx, rx) = mpsc::channel(100);

    // Spawn the tasks
    let api_task = spawn_api_task(tx.clone());
    let file_task = spawn_file_task(tx.clone());
    let sensor_task = spawn_sensor_task(tx.clone());

    // Close the original sender to signal that no more messages will be sent
    drop(tx);

    // Spawn the receiver task to process the data
    let receiver_task = process_data(rx);

    // Wait for all tasks to complete
    tokio::join!(api_task, file_task, sensor_task, receiver_task);
}

async fn spawn_api_task(tx: mpsc::Sender<String>) {
    task::spawn(async move {
        // Simulate a task that fetches data from an API periodically
        loop {
            let data = "API Response".to_string();
            if tx.send(data).await.is_err() {
                println!("Receiver dropped, stopping API task");
                return;
            }
            sleep(Duration::from_secs(3)).await; // Simulate API latency between requests
        }
    }).await.unwrap();
}

async fn spawn_file_task(tx: mpsc::Sender<String>) {
    task::spawn(async move {
        // Simulate reading a file in chunks asynchronously
        // Example: Reading data from a file at certain intervals
        loop {
            let data = "File Data Chunk".to_string();
            if tx.send(data).await.is_err() {
                println!("Receiver dropped, stopping File task");
                return;
            }
            sleep(Duration::from_secs(5)).await; // Simulate file read delay
        }
    }).await.unwrap();
}

async fn spawn_sensor_task(tx: mpsc::Sender<String>) {
    task::spawn(async move {
        // Simulate continuously receiving sensor data
        loop {
            let data = "Sensor Data".to_string();
            if tx.send(data).await.is_err() {
                println!("Receiver dropped, stopping Sensor task");
                return;
            }
            sleep(Duration::from_secs(1)).await; // Simulate sensor data frequency
        }
    }).await.unwrap();
}

async fn process_data(mut rx: mpsc::Receiver<String>) {
    task::spawn(async move {
        // Process incoming data asynchronously
        while let Some(received) = rx.recv().await {
            println!("Processing received: {}", received);
            sleep(Duration::from_millis(50)).await; // Simulate processing time
        }

        println!("All data processed.");
    }).await.unwrap();
}