rust-concurrencylisted

# Rust Concurrency The shape of the workload picks the model. This skill owns that pick for threads, and it stops where task concurrency begins — runtime, executors, `spawn_blocking`, and cancellation live in `/async-rust`. ## The shape picks the model - The same operation over many independent items: data parallelism, `rayon`. - Independent units of work that are mostly waiting: task concurrency, `/async-rust`, not here. - State several threads read and write: shared state — the one to reach for last, because it is the only one of the three that can deadlock. ## Data parallelism `par_iter()` is a one-word change to an iterator chain that already exists — exactly why the chain was worth writing. The precondition: the per-item work has to be large enough to pay for the scheduling. A `par_iter` over a million cheap closures is often slower, and is the standard disappointment. ## Scoped threads `std::thread::scope` lets a thread borrow stack data, because the scope guarantees the join before the stack unwinds — which is what removes the `'static` bound that otherwise forces an `Arc`: ```rust fn sum_halves(data: &[u64]) -> u64 { let (left, right) = data.split_at(data.len() / 2); std::thread::scope(|s| { let a = s.spawn(|| left.iter().sum::<u64>()); let b = s.spawn(|| right.iter().sum::<u64>()); a.join().unwrap() + b.join().unwrap() }) } ``` Reach for a scope before an `Arc` or a clone buys the second thread. ## Channels for handof