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);

Reexports

use self::Ordering::*;

use marker::{Send, Sync};

use intrinsics;

use cell::UnsafeCell;

use default::Default;

use fmt;

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`.
UINT_TRUE

Functions

atomic_add	Returns the old value (like __sync_fetch_and_add).
atomic_and
atomic_compare_and_swap
atomic_load
atomic_nand
atomic_or
atomic_store
atomic_sub	Returns the old value (like __sync_fetch_and_sub).
atomic_swap
atomic_xor
fence	An atomic fence.