Rust Send & Sync

Send and Sync are built into the language itself. Almost every other concurrency tool lives in the standard library or in crates. A type is Sync when sharing &T between threads cannot cause a data race:

use std::thread;
fn main() {
    let word = String::from("movable");
    let h = thread::spawn(move || word.len());
    println!("String is Send: len = {}", h.join().unwrap());
}

Rc is neither Send nor Sync. Arc is both. That is the whole reason Arc exists. RefCell is not Sync. Its borrow checks are not thread-safe. Mutex is Sync:

use std::rc::Rc;
use std::thread;
fn main() {
    let rc = Rc::new(5);
    thread::spawn(move || println!("{}", rc));
    // error E0277: Rc<i32> cannot be sent between threads safely
}

A type is Send when all its parts are Send — Rust works this out for you. Mutex<T> is Send and Sync exactly when T is Send. The lock makes sharing safe. But a value that itself is not Send still cannot move between threads:

fn assert_send<T: Send>() {}
fn assert_sync<T: Sync>() {}
fn main() {
    assert_send::<std::sync::Arc<String>>();
    assert_sync::<std::sync::Mutex<i32>>();
    println!("Arc and Mutex carry both labels");
}

A data race is undefined behaviour — and impossible in safe Rust. A race condition can make a program wrong, but never memory-unsafe: Rust prevents data races, not race conditions:

// data race, exactly: two or more threads touch the same memory
// at the same time, at least one of them writes, and at least
// one access is unsynchronised
// race condition: the result depends on the order threads happen
// to run — a thread checks a value, then acts after another
// thread changed it

These labels have a companion in the atomics lessons of this section. Send and Sync decide whether sharing is allowed at all. A memory Ordering decides something else. It decides what a thread is guaranteed to see when a shared atomic changes. A happens-before edge is the receipt that one thread's writes are visible to another. Three everyday tools each mint one:

// a Mutex unlock, followed by a lock of the same Mutex
// a channel send, followed by the matching recv
// a Release store, followed by an Acquire load on the same atomic

use std::sync::Arc; use std::thread;
fn assert_send<T: Send>(_: &T) {}
fn main() {
    let shared = Arc::new(String::from("thread-safe"));
    assert_send(&shared);
    let copy = Arc::clone(&shared);
    let h = thread::spawn(move || copy.len());
    println!("len across thread = {}", h.join().unwrap());
    // let rc = std::rc::Rc::new(1); assert_send(&rc); // Rc is Send, but sharing &Rc across threads via scope aside, Rc<RefCell> patterns stay single-threaded — Arc is the tool here.
}