Concurrency & Async

Thread Safety

Error Cause Fix

Rc<T> cannot be sent between threads Rc is not Send

Use Arc

RefCell<T> is not Sync

Not thread-safe Use Mutex or RwLock

Cannot mutate through Arc

No interior mutability Arc<Mutex<T>> or Arc<AtomicT>

Deadlock Prevention

• Lock ordering: Always acquire multiple locks in the same order across all threads

• Self-deadlock: Never lock the same std::Mutex twice (use parking_lot::ReentrantMutex if needed)

• Scope locks tightly: Drop guards as soon as possible

• Atomics for primitives: Use AtomicBool /AtomicUsize instead of Mutex<bool>

• Choose memory order carefully: Relaxed / Acquire / Release / SeqCst

Async Patterns

Pattern When to Use

tokio::spawn

Fire-and-forget concurrent tasks

tokio::select!

Race multiple futures, cancel losers

mpsc channel Fan-in: many producers, one consumer

oneshot channel Single request-response

broadcast channel One producer, many consumers

watch channel Latest-value state sharing

JoinSet

Manage group of spawned tasks

CancellationToken

Graceful shutdown signaling

Critical Async Mistakes

Mutex Guard Across Await

// BAD: std::Mutex guard held across .await — blocks executor async fn bad() { let guard = mutex.lock().unwrap(); some_async_op().await; // guard held across await! println!("{}", *guard); }

// GOOD: scope the lock, copy what you need async fn good() { let value = { let guard = mutex.lock().unwrap(); *guard // copy value }; // guard dropped here some_async_op().await; println!("{}", value); }

Blocking in Async Context

// BAD: blocking call in async context async fn bad() { std::thread::sleep(Duration::from_secs(1)); // blocks executor! std::fs::read_to_string("file.txt").unwrap(); // blocks! }

// GOOD: use async equivalents async fn good() { tokio::time::sleep(Duration::from_secs(1)).await; tokio::fs::read_to_string("file.txt").await.unwrap(); }

// For CPU work: spawn_blocking let result = tokio::task::spawn_blocking(|| heavy_computation()).await.unwrap();

Forgetting to Poll Futures

// BAD: future not polled — does nothing! fn process() { fetch_data(); // returns Future that's immediately dropped }

// GOOD: await it async fn process() { let data = fetch_data().await; }

Key Rule

// Sync for CPU-bound work, async for I/O-bound work // Don't hold locks across await points

Channel Disconnection

// Iterate until all senders drop for msg in rx { handle(msg); }

// Explicit matching for non-blocking match rx.try_recv() { Ok(msg) => handle(msg), Err(TryRecvError::Empty) => continue, Err(TryRecvError::Disconnected) => break, }

Thread Panic Handling

let handle = std::thread::spawn(|| risky_operation());

match handle.join() { Ok(result) => use_result(result), Err(e) => eprintln!("Thread panicked: {:?}", e), }

Graceful Shutdown Pattern

use tokio_util::sync::CancellationToken;

async fn run(token: CancellationToken) { loop { tokio::select! { _ = token.cancelled() => { tracing::info!("shutting down"); break; } msg = rx.recv() => { if let Some(msg) = msg { handle(msg).await; } } } } }