# Threads and atomics Use `thread::spawn` for a worker with no input and `thread::spawn_with` to move a value into a worker. Joining consumes the handle and returns the worker's result. ```cplus import "stdlib/thread" as thread; fn worker() -> i32 { return 42; } fn main() -> i32 { let h: thread::JoinHandle[i32] = thread::spawn::[i32](worker); return h.join(); } ``` Partition-and-join is the default shared-nothing shape. `Send` controls which values can move to another thread; `Sync` controls which values may be shared. `Rc[T]` is not `Send`; `Arc[T]`, channels, and mutexes carry the appropriate conditional marker implementations. ## Scoped lending `thread::scope()` permits a worker to borrow a parent local. `Scope::lend` records the loan through `#[keeps(this)]`, and dropping the scope requests cancellation and joins every worker before the borrowed value can disappear. ```cplus var counts: Counts = Counts { hits: 0 }; { var s: thread::Scope = thread::scope(); let started = s.lend::[Counts](counts, tally); } ``` The checker rejects a lent value dying while the scope lives, a conflicting write during the loan, and lending the same exclusive place twice. ## Shared state Use channels before shared mutation. When shared state is required, `stdlib/mutex` provides a refcounted mutex and `stdlib/atomic` provides explicit integer atomics with `Relaxed`, `Acquire`, `Release`, `AcqRel`, and `SeqCst` orderings. The borrow checker does not prevent lock-order deadlocks. See [Concurrency](/docs/concurrency) for the complete model, deadlines, cancellation, generators, and the async/thread bridges. Runnable recipes are under [Threads and atomics](/examples/threads-atomics).