# Enum std::sync::atomic::Ordering 1.0.0[−][src]

    #[non_exhaustive]pub enum Ordering {
        Relaxed,
        Release,
        Acquire,
        AcqRel,
        SeqCst,
    }

Atomic memory orderings

Memory orderings specify the way atomic operations synchronize memory. In its weakest `Ordering::Relaxed`, only the memory directly touched by the operation is synchronized. On the other hand, a store-load pair of `Ordering::SeqCst` operations synchronize other memory while additionally preserving a total order of such operations across all threads.

Rust's memory orderings are the same as those of C++20.

For more information see the nomicon.

## Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.
`Relaxed`

No ordering constraints, only atomic operations.

Corresponds to `memory_order_relaxed` in C++20.

`Release`

When coupled with a store, all previous operations become ordered before any load of this value with `Acquire` (or stronger) ordering. In particular, all previous writes become visible to all threads that perform an `Acquire` (or stronger) load of this value.

Notice that using this ordering for an operation that combines loads and stores leads to a `Relaxed` load operation!

This ordering is only applicable for operations that can perform a store.

Corresponds to `memory_order_release` in C++20.

`Acquire`

When coupled with a load, if the loaded value was written by a store operation with `Release` (or stronger) ordering, then all subsequent operations become ordered after that store. In particular, all subsequent loads will see data written before the store.

Notice that using this ordering for an operation that combines loads and stores leads to a `Relaxed` store operation!

This ordering is only applicable for operations that can perform a load.

Corresponds to `memory_order_acquire` in C++20.

`AcqRel`

Has the effects of both `Acquire` and `Release` together: For loads it uses `Acquire` ordering. For stores it uses the `Release` ordering.

Notice that in the case of `compare_and_swap`, it is possible that the operation ends up not performing any store and hence it has just `Acquire` ordering. However, `AcqRel` will never perform `Relaxed` accesses.

This ordering is only applicable for operations that combine both loads and stores.

Corresponds to `memory_order_acq_rel` in C++20.

`SeqCst`

Like `Acquire`/`Release`/`AcqRel` (for load, store, and load-with-store operations, respectively) with the additional guarantee that all threads see all sequentially consistent operations in the same order.

Corresponds to `memory_order_seq_cst` in C++20.

## Trait Implementations

### `impl Clone for Ordering`[src]

#### `pub fn clone(&self) -> Ordering`[src]

Returns a copy of the value. Read more

#### `pub fn clone_from(&mut self, source: &Self)`[src]

Performs copy-assignment from `source`. Read more

### `impl Copy for Ordering`[src]

### `impl Debug for Ordering`[src]

#### `pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

Formats the value using the given formatter. Read more

### `impl Eq for Ordering`[src]

### `impl Hash for Ordering`[src]

#### `pub fn hash<__H>(&self, state: &mut __H) where
__H: Hasher,` [src]

Feeds this value into the given `Hasher`. Read more

#### `pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,` 1.3.0[src]

Feeds a slice of this type into the given `Hasher`. Read more

### `impl PartialEq<Ordering> for Ordering`[src]

#### `pub fn eq(&self, other: &Ordering) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use]pub fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl StructuralEq for Ordering`[src]

### `impl StructuralPartialEq for Ordering`[src]

## Auto Trait Implementations

### `impl RefUnwindSafe for Ordering`[src]

### `impl Send for Ordering`[src]

### `impl Sync for Ordering`[src]

### `impl Unpin for Ordering`[src]

### `impl UnwindSafe for Ordering`[src]

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId`[src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &Tⓘ

### Notable traits for &'_ mut F

`impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for &mut Rimpl<W: Write + ?Sized> Write for &mut W`
`[src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut Tⓘ

### Notable traits for &'_ mut F

`impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for &mut Rimpl<W: Write + ?Sized> Write for &mut W`
`[src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T`[src]

#### `pub fn from(t: T) -> T`[src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U`[src]

Performs the conversion.

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `pub fn to_owned(&self) -> T`[src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `pub fn clone_into(&self, target: &mut T)`[src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into` #41263)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

Performs the conversion.