# Threads, Send, and Sync
Move or borrow data across threads, then handle completion and failure.
Canonical: https://rust.robertdevore.com/course/16-threads/
Author: Robert DeVore
Technical baseline: Rust 1.98.1, edition 2024; verified 2026-09-06.
## Pass data to a thread
A thread can outlive the function that started it. Ordinary `thread::spawn` therefore requires a closure and result satisfying `Send + 'static`. Owned data can satisfy that bound without living forever. A borrowed local cannot simply be sent into a potentially longer-lived thread.
Scoped threads give a different guarantee: they finish before the scope returns. This permits borrowing data that remains valid for that scope.
### Run the example
```sh
cargo run --locked --example 16_threads
```
```rust
fn main() {
let rows = ["INFO a", "WARN b", "WARN c", "ERROR d"];
let total = std::thread::scope(|scope| {
let left = scope.spawn(|| rows[..2].iter().filter(|r| r.starts_with("WARN ")).count());
let right = scope.spawn(|| rows[2..].iter().filter(|r| r.starts_with("WARN ")).count());
left.join().unwrap() + right.join().unwrap()
});
assert_eq!(total, 2);
}
```
[View the tested source](https://github.com/robertdevore/rust.robertdevore.com/blob/main/examples/16_threads.rs)
Two threads read disjoint ranges of the same immutable array. They return counts, and the parent combines them. No lock is needed because there is no shared mutation. `join` also reports a worker panic. The example uses `unwrap` so a panic fails the example. In an application, decide how to report that failure.
## What Send and Sync mean
`Send` means a value can safely be transferred to another thread. `Sync` means a shared reference to the type can safely be transferred between threads. More precisely, `T: Sync` relates to `&T: Send`. These are unsafe traits to implement manually; normally let their automatic derivation from fields describe your type.
`Rc` is not `Send` because its reference count is not synchronized. `Arc` synchronizes ownership bookkeeping. Sharing mutable inner data still needs an appropriate mechanism and trait bounds. Using `Arc` alone does not make access to the data safe.
## Compiler drill
**Intentionally fails on Rust 1.98.1.** Run `rustc --edition=2024 drills/send.rs` from the repository.
```rust
fn main() {
let value = std::rc::Rc::new(1);
std::thread::spawn(move || println!("{value}"));
}
```
Actual compiler diagnostic ยท Rust 1.98.1
```text
error[E0277]: `Rc` cannot be sent between threads safely
--> drills/send.rs:3:24
|
3 | std::thread::spawn(move || println!("{value}"));
| ------------------ -------^^^^^^^^^^^^^^^^^^^^
| | |
| | `Rc` cannot be sent between threads safely
| | within this `{closure@drills/send.rs:3:24: 3:31}`
| required by a bound introduced by this call
|
= help: within `{closure@drills/send.rs:3:24: 3:31}`, the trait `Send` is not implemented for `Rc`
note: required because it's used within this closure
--> drills/send.rs:3:24
|
3 | std::thread::spawn(move || println!("{value}"));
| ^^^^^^^
note: required by a bound in `spawn`
--> /rustc/48a229ceaefd4985c50990b14116b6d856af0985/library/std/src/thread/functions.rs:125:0
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0277`.
```
Solution and acceptance check
The move-only version captures an owned value. The shared version clones an `Arc` handle before spawning and joins the thread. Scoped borrows are valid because the scope waits for workers, and shared immutable access does not require a lock. Each version should terminate and produce the same value without ignoring a join result.