Rust Concurrency: Threads, Channels, Mutex, Arc, Send and Sync

Rust Learning Path — Chapter 21. Rust's ownership and type systems extend naturally into concurrent programming. Many data-race mistakes that would become runtime bugs in other languages are rejected at compile time. This chapter covers threads, message passing, shared state, Mutex, Arc, and the Send/Sync marker traits.

1. Spawn a thread#

join() waits for the spawned thread to finish.

2. move captured values into a thread#

The move closure takes ownership so the spawned thread cannot outlive borrowed stack data.

3. Message passing with channels#

4. Multiple producers#

Each sender can be moved into a different worker. The receiver consumes incoming messages.

5. Shared mutable state with Mutex#

A mutex allows only one holder of the protected value at a time.

6. Share ownership with Arc#

7. Keep lock scopes small#

Holding a lock while doing slow work reduces concurrency and can contribute to deadlocks. Acquire the guard as late as possible and release it as early as possible.

8. Send and Sync#

Send indicates a type can safely transfer ownership to another thread. Sync indicates shared references can be used safely across threads. Most ordinary Rust types implement these automatically when their contents permit it.

9. Why Rc is not for threads#

Rc uses non-atomic reference counting and is not Send. Use Arc when ownership must be shared across threads.

10. Thread pools#

Creating one OS thread for every tiny job does not scale indefinitely. Production servers typically use a pool or an asynchronous runtime. Chapter 22 moves from OS-thread primitives into Tokio's async task model.

11. Panic handling#

12. Common concurrency mistakes#

• Holding mutex guards across expensive work.
• Using shared state when message passing would be simpler.
• Creating unbounded numbers of threads.
• Ignoring worker panics.
• Attempting to use Rc or RefCell across threads.

13. Mini lab: parallel counter#

Create eight workers. Give each worker a vector slice or independent unit of work, send results back over a channel, and aggregate them on the main thread. Then implement a second version with Arc and compare the designs.

Key takeaways#

Rust makes ownership part of concurrency design. Prefer the simplest model: isolated ownership first, messages when workers exchange data, and shared synchronization only when state truly must be shared.