core::marker

Trait core::marker::Sync [−] [src]

pub unsafe trait Sync { }

Types that can be safely shared between threads when aliased.

The precise definition is: a type T`Tis` is Sync`Syncif` if &T`&Tis thread-safe. In other words, there is no possibility of data races when passing&T` references between threads.

As one would expect, primitive types like u8`u8and` and f64`f64are all` are all Sync`Sync, and so are simple aggregate types containing them (like tuples, structs and enums). More instances of basicSynctypes include "immutable" types like&Tand those with simple inherited mutability, such asBox,`, Vec<T>`Vecand most other collection types. (Generic parameters need to beSyncfor their container to beSync`.)

A somewhat surprising consequence of the definition is &mut T`&mut Tis` is Sync`Sync(if` (if T`Tis` is Sync`Sync) even though it seems that it might provide unsynchronised mutation. The trick is a mutable reference stored in an aliasable reference (that is,& &mut T) becomes read-only, as if it were a& &T`, hence there is no risk of a data race.

Types that are not Sync`Syncare those that have "interior mutability" in a non-thread-safe way, such asCelland` and RefCell`RefCellin` in std::cell. These types allow for mutation of their contents even when in an immutable, aliasable slot, e.g. the contents of &Cell<T>`&Cellcan be` can be .set`.set, and do not ensure data races are impossible, hence they cannot beSync. A higher level example of a non-Synctype is the reference counted pointerstd::rc::Rc, because any reference&Rc` can clone a new reference, which modifies the reference counts in a non-atomic way.

For cases when one does need thread-safe interior mutability, types like the atomics in std::sync and Mutex`Mutex&` & RWLock`RWLockin the` in the sync`synccrate do ensure that any mutation cannot cause data races. Hence these types areSync`.

Any types with interior mutability must also use the std::cell::UnsafeCell wrapper around the value(s) which can be mutated when behind a &`&reference; not doing this is undefined behaviour (for example,transmute-ing from&Tto` to &mut T`&mut T` is invalid).

Implementors