Concurrency in Rust

# CHAPTER 22

Concurrency in Rust #

1. Chapter Introduction #

2. Learning Objectives #

• Spawn new OS threads.

• Force the main thread to wait using join().

• Move data into threads using the move keyword.

• Communicate between threads using Message Passing (Channels).

• Share memory securely between threads using Mutex and Arc.

3. Spawning Threads #

use std::thread;
use std::time::Duration;

fn main() {
    // 1. Spawn a new thread
    let handle = thread::spawn(|| {
        for i in 1..=5 {
            println!("Hi number {} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    // 2. Main thread does its own work
    for i in 1..=3 {
        println!("Hi number {} from the MAIN thread!", i);
        thread::sleep(Duration::from_millis(1));
    }

    // 3. Wait for the spawned thread to finish before the program exits
    handle.join().unwrap();
}

*If we did not call handle.join(), the main thread would reach the end of the file and instantly shut down the entire program, killing the spawned thread before it could finish!*

4. The move Keyword #

use std::thread;

fn main() {
    let data = vec![1, 2, 3];

    // 'move' forces the closure to take ownership of 'data'
    let handle = thread::spawn(move || {
        println!("Here's a vector: {:?}", data);
    });

    // println!("{:?}", data); // ERROR! Main thread no longer owns 'data'
    handle.join().unwrap();
}

5. Message Passing (Channels) #

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

fn main() {
    // tx = Transmitter (Producer), rx = Receiver (Consumer)
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let msg = String::from("Hello from the thread!");
        tx.send(msg).unwrap(); // Sends the message down the channel
    });

    // The main thread waits to receive the message
    let received = rx.recv().unwrap();
    println!("Main thread got: {}", received);
}

6. Shared State (Mutex and Arc) #

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

fn main() {
    // Create a thread-safe shared counter
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    // Spawn 10 threads
    for _ in 0..10 {
        let counter_clone = Arc::clone(&counter);
        
        let handle = thread::spawn(move || {
            // Lock the mutex. This thread now has exclusive access!
            let mut num = counter_clone.lock().unwrap();
            *num += 1;
            // The lock is automatically released when 'num' goes out of scope here.
        });
        handles.push(handle);
    }

    // Wait for all threads to finish
    for handle in handles {
        handle.join().unwrap();
    }

    // Print final result
    println!("Final counter: {}", *counter.lock().unwrap()); // 10
}

7. Mini Project: Concurrent Task Runner #

8. Common Mistakes #

• Forgetting join(): Spawning threads but forgetting to join them will cause the main thread to exit instantly, making it look like your threads never ran.

• Using Rc instead of Arc: The compiler will scream at you if you try to pass Rc across threads. Rc is not thread-safe. You must use Arc.

9. Best Practices #

• Prefer Message Passing over Mutexes: Go (Golang) famously says: *"Do not communicate by sharing memory; instead, share memory by communicating."* Using channels (mpsc) is generally easier to reason about and less prone to Deadlocks than using massive Arc<Mutex<T>> structures.

10. Exercises #

1. 1. Create an mpsc channel.

1. 2. Spawn a thread that sends the number 42 through the transmitter.

1. 3. In main, receive the number and print it.

11. MCQs with Answers #

12. Interview Questions #

• Q: What is a Data Race, and how does Rust's Ownership model completely prevent it?

• Q: Explain the difference between Rc and Arc. Why can't Rc be used across threads?

13. Summary #

14. Next Chapter Recommendation #