# Module core::sync::atomic [−] [src]

Atomic types

Atomic types provide primitive shared-memory communication between threads, and are the building blocks of other concurrent types.

This module defines atomic versions of a select number of primitive types, including `AtomicBool`, `AtomicIsize`, and `AtomicUsize`. Atomic types present operations that, when used correctly, synchronize updates between threads.

Each method takes an `Ordering` which represents the strength of the memory barrier for that operation. These orderings are the same as LLVM atomic orderings.

Atomic variables are safe to share between threads (they implement `Sync`) but they do not themselves provide the mechanism for sharing. The most common way to share an atomic variable is to put it into an `Arc` (an atomically-reference-counted shared pointer).

Most atomic types may be stored in static variables, initialized using the provided static initializers like `INIT_ATOMIC_BOOL`. Atomic statics are often used for lazy global initialization.

# Examples

A simple spinlock:

use std::sync::Arc; use std::sync::atomic::{AtomicUsize, Ordering}; use std::thread; fn main() { let spinlock = Arc::new(AtomicUsize::new(1)); let spinlock_clone = spinlock.clone(); thread::spawn(move|| { spinlock_clone.store(0, Ordering::SeqCst); }); // Wait for the other thread to release the lock while spinlock.load(Ordering::SeqCst) != 0 {} }

    use std::sync::Arc;
    use std::sync::atomic::{AtomicUsize, Ordering};
    use std::thread;

    fn main() {
        let spinlock = Arc::new(AtomicUsize::new(1));

        let spinlock_clone = spinlock.clone();
        thread::spawn(move|| {
            spinlock_clone.store(0, Ordering::SeqCst);
        });

        // Wait for the other thread to release the lock
        while spinlock.load(Ordering::SeqCst) != 0 {}
    }

Keep a global count of live threads:

fn main() { use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT}; static GLOBAL_THREAD_COUNT: AtomicUsize = ATOMIC_USIZE_INIT; let old_thread_count = GLOBAL_THREAD_COUNT.fetch_add(1, Ordering::SeqCst); println!("live threads: {}", old_thread_count + 1); }

    use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};

    static GLOBAL_THREAD_COUNT: AtomicUsize = ATOMIC_USIZE_INIT;

    let old_thread_count = GLOBAL_THREAD_COUNT.fetch_add(1, Ordering::SeqCst);
    println!("live threads: {}", old_thread_count + 1);

## Structs

AtomicBool | A boolean type which can be safely shared between threads.
AtomicIsize | A signed integer type which can be safely shared between threads.
AtomicPtr | A raw pointer type which can be safely shared between threads.
AtomicUsize | An unsigned integer type which can be safely shared between threads.

## Enums

Ordering | Atomic memory orderings

## Constants

ATOMIC_BOOL_INIT | An `AtomicBool` initialized to `false`.
ATOMIC_ISIZE_INIT | An `AtomicIsize` initialized to `0`.
ATOMIC_USIZE_INIT | An `AtomicUsize` initialized to `0`.

## Functions

fence | An atomic fence.

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)