Chapter 7: Fearless Concurrency

Rust's ownership system enables "fearless concurrency" - the ability to write concurrent code with confidence that the compiler will catch data races before they happen. This chapter covers threads, message passing, shared state, and the traits that make it all work.

7.1 Creating Threads

Spawn threads using thread::spawn, which takes a closure that runs in the new thread:

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

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

    // Main thread continues
    for i in 1..5 {
        println!("main thread: {}", i);
        thread::sleep(Duration::from_millis(1));
    }

    // Wait for spawned thread to finish
    handle.join().unwrap();
    println!("All threads completed!");
}

7.2 Move Closures

Use the move keyword to transfer ownership of captured variables to the thread:

use std::thread;

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

    // move transfers ownership of v to the thread
    let handle = thread::spawn(move || {
        println!("vector: {:?}", v);
    });

    // println!("{:?}", v);  // ERROR: v was moved to the thread

    handle.join().unwrap();
}

Sharing Data Between Threads

use std::thread;

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

    // Clone data for each thread
    let numbers_clone = numbers.clone();

    let handle = thread::spawn(move || {
        let sum: i32 = numbers_clone.iter().sum();
        println!("Sum in thread: {}", sum);
    });

    println!("Original: {:?}", numbers);  // Still available
    handle.join().unwrap();
}

7.3 Message Passing with Channels

Channels provide safe communication between threads following the motto: "Do not communicate by sharing memory; instead, share memory by communicating."

use std::sync::mpsc;  // multiple producer, single consumer
use std::thread;

fn main() {
    // Create a channel
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let msg = String::from("hello from thread");
        tx.send(msg).unwrap();
        // println!("{}", msg);  // ERROR: msg was moved into channel
    });

    // Receive blocks until a message is available
    let received = rx.recv().unwrap();
    println!("Got: {}", received);
}

Sending Multiple Values

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let messages = vec![
            String::from("hello"),
            String::from("from"),
            String::from("the"),
            String::from("thread"),
        ];

        for msg in messages {
            tx.send(msg).unwrap();
            thread::sleep(Duration::from_millis(200));
        }
    });

    // Iterate over received messages
    for received in rx {
        println!("Got: {}", received);
    }
}

Multiple Producers

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

fn main() {
    let (tx, rx) = mpsc::channel();
    let tx2 = tx.clone();  // Clone the sender

    thread::spawn(move || {
        tx.send(String::from("from tx1")).unwrap();
    });

    thread::spawn(move || {
        tx2.send(String::from("from tx2")).unwrap();
    });

    // Receive from both producers
    for received in rx {
        println!("Got: {}", received);
    }
}

Channel Methods

Method	Behavior
rx.recv()	Blocks until a message is received or channel closes
rx.try_recv()	Returns immediately with Result (non-blocking)
rx.recv_timeout(duration)	Blocks for specified duration, then returns error
tx.send(value)	Sends value, returns error if receiver dropped

7.4 Shared State with Mutex

Mutex (mutual exclusion) provides safe access to shared data - only one thread at a time can access the data:

use std::sync::Mutex;

fn main() {
    let m = Mutex::new(5);

    {
        // Acquire lock - blocks until available
        let mut num = m.lock().unwrap();
        *num = 6;
    }  // Lock released here when MutexGuard goes out of scope

    println!("m = {:?}", m);  // Mutex { data: 6, ... }
}

7.5 Arc: Thread-Safe Shared Ownership

Arc (Atomic Reference Counting) allows multiple threads to own shared data. It's the thread-safe version of Rc:

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

fn main() {
    // Arc allows multiple owners across threads
    // Mutex allows mutation by one thread at a time
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);  // Clone the Arc
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

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

    println!("Result: {}", *counter.lock().unwrap());  // 10
}

7.6 Send and Sync Traits

Two marker traits govern thread safety in Rust:

Trait	Meaning	Example Types
Send	Type can be transferred between threads	Most types: String, Vec, i32
Sync	Type can be referenced from multiple threads	Immutable references, Mutex<T>

// Types that are NOT Send or Sync
// Rc is NOT Send - use Arc instead
// RefCell is NOT Sync - use Mutex instead
// Raw pointers are neither

// If all components of a type are Send, the type is Send
// If all components of a type are Sync, the type is Sync

7.7 Async/Await Preview

Rust also supports async programming for I/O-bound tasks. While threads are great for CPU-bound parallel work, async is more efficient for handling many concurrent I/O operations:

// Requires an async runtime like tokio
use tokio;

#[tokio::main]
async fn main() {
    let result = fetch_data().await;
    println!("{}", result);

    // Run multiple futures concurrently
    let (r1, r2) = tokio::join!(
        fetch_data(),
        fetch_data()
    );
}

async fn fetch_data() -> String {
    // Simulate async I/O operation
    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
    "data".to_string()
}

7.8 Chapter Summary

7.9 Review Questions

7.10 Looking Ahead