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 basic
Synctypes include "immutable" types like
&Tand those with simple inherited mutability, such as
Box,
`, Vec<T>
`Vecand most other collection types. (Generic parameters need to be
Syncfor their container to be
Sync`.)
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 as
Celland
` 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 be
Sync. A higher level example of a non-
Synctype is the reference counted pointer
std::rc::Rc, because any reference
&Rc
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 are
Sync`.
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
impl<T: Sync + ?Sized> Sync for Unique<T>
impl<T> !Sync for *const T
impl<T> !Sync for *mut T
impl Sync for AtomicBool
impl Sync for AtomicIsize
impl Sync for AtomicUsize
impl<T> Sync for AtomicPtr<T>
impl<T: ?Sized> !Sync for UnsafeCell<T>
impl<'a, T: Sync> Sync for Iter<'a, T>
impl<'a, T: Sync> Sync for IterMut<'a, T>