Rust Concurrency Practice: Threads, Mutex, Channels & Arc

thread::spawn requires FnOnce + Send + 'static. A closure that borrows local data cannot satisfy 'static:

// WRONG: closure borrows v, but thread may outlive the function
// let v = vec![1, 2, 3];
// thread::spawn(|| {
//     println!("{v:?}");  // error[E0373]
// });

// RIGHT: move ownership into the thread
let v = vec![1, 2, 3];
thread::spawn(move || {
    println!("{v:?}");  // v moved into thread
}).join().unwrap();

If you need to borrow data across threads without moving it, use scoped threads. The scope guarantees all threads join before returning:

let v = vec![1, 2, 3];
let mut results = vec![];

thread::scope(|s| {
    s.spawn(|| {
        println!("{v:?}");  // borrows &v — no move needed
    });
    s.spawn(|| {
        results.push(v.len());  // borrows &mut results — safe!
    });
});
// all threads have joined here — v and results are still usable
println!("{results:?}");

thread::scope eliminates the need for Arc in many cases. Use it when all threads should finish before moving on.

Moving a Mutex into thread::spawn transfers ownership on the first iteration. The second iteration tries to move it again:

// WRONG: Mutex moved into first thread, gone on second iteration
// let counter = Mutex::new(0);
// for _ in 0..10 {
//     thread::spawn(move || {
//         *counter.lock().unwrap() += 1;  // error[E0382] on 2nd iter
//     });
// }

// RIGHT: Wrap in Arc, clone before each spawn
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
for _ in 0..10 {
    let counter = Arc::clone(&counter);
    let handle = thread::spawn(move || {
        *counter.lock().unwrap() += 1;
    });
    handles.push(handle);
}
for handle in handles {
    handle.join().unwrap();
}
println!("Result: {}", *counter.lock().unwrap());

Arc::clone creates a new reference-counted pointer (cheap — no data copy). Each thread gets its own Arc pointing to the same Mutex.

Rc uses non-atomic reference counting and does not implement Send. The compiler rejects it at thread boundaries:

// WRONG: Rc is not Send
// use std::rc::Rc;
// let data = Rc::new(vec![1, 2, 3]);
// thread::spawn(move || {
//     println!("{data:?}");  // error[E0277]: Rc cannot be sent
// });

// RIGHT: Arc uses atomic reference counting (thread-safe)
use std::sync::Arc;
let data = Arc::new(vec![1, 2, 3]);
let data_clone = Arc::clone(&data);
thread::spawn(move || {
    println!("{data_clone:?}");
}).join().unwrap();

Send and Sync

Send means ownership can be transferred between threads. Sync means references can be shared — formally, T is Sync if and only if &T is Send. Most standard types are both. Rc, Cell, and raw pointers are neither. The smart pointers guide covers Rc vs Arc and when to pair Arc with Mutex.

Holding a MutexGuard across long operations blocks all other threads waiting on that lock:

// WRONG: guard held during expensive work
// let data = Arc::new(Mutex::new(vec![]));
// let mut guard = data.lock().unwrap();
// let result = expensive_computation();  // other threads blocked!
// guard.push(result);

// RIGHT: lock briefly, release before slow work
let data = Arc::new(Mutex::new(vec![]));
let result = expensive_computation();    // no lock held
data.lock().unwrap().push(result);       // lock, push, guard drops

// Or use a scope to make the drop point explicit:
{
    let mut guard = data.lock().unwrap();
    guard.push(another_result);
}  // guard drops here

When a thread panics while holding a lock, the Mutex becomes poisoned. Future .lock() calls return Err:

// WRONG: .unwrap() crashes if any thread panicked
// let value = mutex.lock().unwrap();

// RIGHT: handle poisoning explicitly
let value = mutex.lock().unwrap_or_else(|poisoned| {
    eprintln!("Mutex poisoned, recovering");
    poisoned.into_inner()  // get the data anyway
});

Decide your policy: propagate the panic (.unwrap() is fine if a panic means a bug), or recover with .into_inner() if the data might still be usable. The ownership and borrowing rules are exactly what prevent data races in Rust -- the move keyword in thread closures transfers ownership cleanly.

For I/O-bound concurrency, async Rust with tokio::spawn offers a lighter-weight alternative to OS threads. Use channels when you can model the problem as passing work or results:

use std::sync::mpsc;

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

thread::spawn(move || {
    tx.send("hello").unwrap();
});

let msg = rx.recv().unwrap();
println!("{msg}");

Multiple Producers

Clone the sender for each thread. Drop the original so the receiver knows when all senders are done:

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

for i in 0..3 {
    let tx = tx.clone();
    thread::spawn(move || {
        tx.send(i).unwrap();
    });
}
drop(tx);  // drop original so rx iterator terminates

for val in rx {
    println!("{val}");
}

WRONG → RIGHT: Channel Hangs Forever

If any sender remains alive, rx.recv() blocks forever waiting for more messages:

// WRONG: original tx still alive — rx never terminates
// let (tx, rx) = mpsc::channel();
// let tx2 = tx.clone();
// thread::spawn(move || { tx2.send(1).unwrap(); });
// for val in rx { println!("{val}"); }  // hangs!

// RIGHT: drop all senders when done
let (tx, rx) = mpsc::channel();
let tx2 = tx.clone();
thread::spawn(move || { tx2.send(1).unwrap(); });
drop(tx);  // drop original — receiver terminates after tx2 drops
for val in rx { println!("{val}"); }

Bounded Channels: Backpressure with sync_channel

mpsc::channel() is unbounded — fast producers can exhaust memory. Use sync_channel(n) to cap the buffer:

let (tx, rx) = mpsc::sync_channel(10);  // buffer holds 10 messages

thread::spawn(move || {
    for i in 0..100 {
        tx.send(i).unwrap();  // blocks when buffer is full
    }
});

for val in rx {
    println!("{val}");
}

When reads vastly outnumber writes, RwLock allows concurrent readers while writes get exclusive access:

use std::sync::{Arc, RwLock};

let config = Arc::new(RwLock::new(String::from("v1")));

// Multiple readers can proceed concurrently
let config_r = Arc::clone(&config);
thread::spawn(move || {
    let val = config_r.read().unwrap();
    println!("Config: {val}");
});

// Writer gets exclusive access
let config_w = Arc::clone(&config);
thread::spawn(move || {
    let mut val = config_w.write().unwrap();
    *val = String::from("v2");
});

Use RwLock for read-heavy workloads (config, caches). Use Mutex when reads and writes are roughly equal — it's simpler and has less overhead.

• The Rust Book: Threads — spawning, join handles, move closures
• The Rust Book: Message Passing — mpsc channels
• The Rust Book: Shared-State Concurrency — Mutex, Arc
• std::thread::scope — scoped threads (borrow without move)
• std::sync::mpsc — channel API, dropping senders