What are some advanced examples of threading in Rust?

What are some advanced examples of threading in Rust?

In Rust, advanced threading can involve using the std::thread module along with synchronization primitives like Mutex and RwLock. For example, you can create a thread pool to manage multiple threads efficiently.

Can you show me a code example of a thread pool?

Sure! Here's a simple thread pool implementation:

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

struct ThreadPool {
    workers: Vec<Worker>,
}

struct Worker {
    id: usize,
    thread: Option<thread::JoinHandle<()>>, 
}

impl ThreadPool {
    fn new(size: usize) -> ThreadPool {
        let mut workers = Vec::with_capacity(size);
        for id in 0..size {
            workers.push(Worker::new(id));
        }
        ThreadPool { workers }
    }
}

impl Worker {
    fn new(id: usize) -> Worker {
        let thread = thread::spawn(move || {
            println!("Worker {} is running", id);
        });
        Worker { id, thread: Some(thread) }
    }
}

This creates a basic thread pool with a specified number of workers.

What about using channels for communication between threads?

Great question! Rust's channels allow threads to communicate safely. You can use std::sync::mpsc for this. Here's a quick example:

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

let (tx, rx) = mpsc::channel();

thread::spawn(move || {
    let val = String::from("Hello from thread!");
    tx.send(val).unwrap();
});

let received = rx.recv().unwrap();
println!("Received: {}", received);

This code sends a message from one thread to another using a channel.