CODEWITHSUNDEEP
rust
TalG
TalG

Reputation: 748

How can I send a message to a specific thread?

I need to create some threads where some of them are going to run until their runner variable value has been changed. This is my minimal code.

use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;

fn main() {
    let mut log_runner = Arc::new(Mutex::new(true));
    println!("{}", *log_runner.lock().unwrap());
    let mut threads = Vec::new();

    {
        let mut log_runner_ref = Arc::clone(&log_runner);
        // log runner thread
        let handle = thread::spawn(move || {
            while *log_runner_ref.lock().unwrap() == true {
                // DO SOME THINGS CONTINUOUSLY
                println!("I'm a separate thread!");
            }
        });
        threads.push(handle);
    }

    // let the main thread to sleep for x time
    thread::sleep(Duration::from_millis(1));
    // stop the log_runner thread
    *log_runner.lock().unwrap() = false;
    // join all threads
    for handle in threads {
        handle.join().unwrap();
        println!("Thread joined!");
    }
    println!("{}", *log_runner.lock().unwrap());
}

It looks like I'm able to set the log_runner_ref in the log runner thread after 1 second to false. Is there a way to mark the treads with some name / ID or something similar and send a message to a specific thread using its specific marker (name / ID)?

If I understand it correctly, then the let (tx, rx) = mpsc::channel(); can be used for sending messages to all the threads simultaneously rather than to a specific one. I could send some identifier with the messages and each thread will be looking for its own identifier for the decision if to act on received message or not, but I would like to avoid the broadcasting effect.

Upvotes: 0

Views: 409

Answers (1)

Sébastien Renauld
Sébastien Renauld

Reputation: 19672

MPSC stands for Multiple Producers, Single Consumer. As such, no, you cannot use that by itself to send a message to all threads, since for that you'd have to be able to duplicate the consumer. There are tools for this, but the choice of them requires a bit more info than just "MPMC" or "SPMC".

Honestly, if you can rely on channels for messaging (there are cases where it'd be a bad idea), you can create a channel per thread, assign the ID outside of the thread, and keep a HashMap instead of a Vec with the IDs associated to the threads. Receiver<T> can be moved into the thread (it implements Send if T implements Send), so you can quite literally move it in.

You then keep the Sender outside and send stuff to it :-)

Upvotes: 1

Related Questions