rust-concurrency

A future is not Send when a non-Send value like Rc or a std MutexGuard is held across an .await point. Replace Rc with Arc, drop the value before the await, or restructure so the non-Send value is created and dropped between awaits.

Use OS threads or rayon for CPU-bound work like parsing and hashing, where real parallelism across cores matters. Use async with tokio for I/O-bound work with many concurrent connections, where cheap tasks outperform thread-per-connection.

Prefer channels and message passing by default, since they turn data races into ownership transfers the compiler checks. Use Arc<Mutex<T>> only when data genuinely must be shared in place, or use the actor pattern where one task owns the state.

Deadlocks happen when a std MutexGuard is held across an .await, blocking the executor thread. Fix it by computing the value first, then locking briefly to store it, or use tokio::sync::Mutex only when the lock must span an await.

parking_lot::Mutex is smaller, faster under low contention, and does not poison, so lock() returns the guard directly without unwrap. std locks have closed much of the performance gap, so switch only if profiling shows lock overhead.

Combine a CancellationToken to signal stop with a TaskTracker to wait for tasks to drain. Tasks select on token.cancelled() to exit their loops, then tracker.wait() ensures in-flight work finishes before the process exits.