# Struct core::sync::atomic::AtomicUsize [−] [src]

    pub struct AtomicUsize {
        // some fields omitted
    }

An unsigned integer type which can be safely shared between threads.

## Methods

### `impl AtomicUsize`

#### `const fn new(v: usize) -> AtomicUsize`

Creates a new `AtomicUsize`.

# Examples

fn main() { use std::sync::atomic::AtomicUsize; let atomic_forty_two = AtomicUsize::new(42); }

    use std::sync::atomic::AtomicUsize;

    let atomic_forty_two = AtomicUsize::new(42);

#### `fn load(&self, order: Ordering) -> usize`

Loads a value from the usize.

`load` takes an `Ordering` argument which describes the memory ordering of this operation.

# Panics

Panics if `order` is `Release` or `AcqRel`.

# Examples

fn main() { use std::sync::atomic::{AtomicUsize, Ordering}; let some_usize = AtomicUsize::new(5); assert_eq!(some_usize.load(Ordering::Relaxed), 5); }

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

    let some_usize = AtomicUsize::new(5);

    assert_eq!(some_usize.load(Ordering::Relaxed), 5);

#### `fn store(&self, val: usize, order: Ordering)`

Stores a value into the usize.

`store` takes an `Ordering` argument which describes the memory ordering of this operation.

# Examples

fn main() { use std::sync::atomic::{AtomicUsize, Ordering}; let some_usize = AtomicUsize::new(5); some_usize.store(10, Ordering::Relaxed); assert_eq!(some_usize.load(Ordering::Relaxed), 10); }

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

    let some_usize = AtomicUsize::new(5);

    some_usize.store(10, Ordering::Relaxed);
    assert_eq!(some_usize.load(Ordering::Relaxed), 10);

# Panics

Panics if `order` is `Acquire` or `AcqRel`.

#### `fn swap(&self, val: usize, order: Ordering) -> usize`

Stores a value into the usize, returning the old value.

`swap` takes an `Ordering` argument which describes the memory ordering of this operation.

# Examples

fn main() { use std::sync::atomic::{AtomicUsize, Ordering}; let some_usize= AtomicUsize::new(5); assert_eq!(some_usize.swap(10, Ordering::Relaxed), 5); assert_eq!(some_usize.load(Ordering::Relaxed), 10); }

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

    let some_usize= AtomicUsize::new(5);

    assert_eq!(some_usize.swap(10, Ordering::Relaxed), 5);
    assert_eq!(some_usize.load(Ordering::Relaxed), 10);

#### `fn compare_and_swap(&self, current: usize, new: usize, order: Ordering) -> usize`

Stores a value into the `usize` if the current value is the same as the `current` value.

The return value is always the previous value. If it is equal to `current`, then the value was updated.

`compare_and_swap` also takes an `Ordering` argument which describes the memory ordering of this operation.

# Examples

fn main() { use std::sync::atomic::{AtomicUsize, Ordering}; let some_usize = AtomicUsize::new(5); assert_eq!(some_usize.compare_and_swap(5, 10, Ordering::Relaxed), 5); assert_eq!(some_usize.load(Ordering::Relaxed), 10); assert_eq!(some_usize.compare_and_swap(6, 12, Ordering::Relaxed), 10); assert_eq!(some_usize.load(Ordering::Relaxed), 10); }

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

    let some_usize = AtomicUsize::new(5);

    assert_eq!(some_usize.compare_and_swap(5, 10, Ordering::Relaxed), 5);
    assert_eq!(some_usize.load(Ordering::Relaxed), 10);

    assert_eq!(some_usize.compare_and_swap(6, 12, Ordering::Relaxed), 10);
    assert_eq!(some_usize.load(Ordering::Relaxed), 10);

#### `fn fetch_add(&self, val: usize, order: Ordering) -> usize`

Add to the current usize, returning the previous value.

# Examples

fn main() { use std::sync::atomic::{AtomicUsize, Ordering}; let foo = AtomicUsize::new(0); assert_eq!(foo.fetch_add(10, Ordering::SeqCst), 0); assert_eq!(foo.load(Ordering::SeqCst), 10); }

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

    let foo = AtomicUsize::new(0);
    assert_eq!(foo.fetch_add(10, Ordering::SeqCst), 0);
    assert_eq!(foo.load(Ordering::SeqCst), 10);

#### `fn fetch_sub(&self, val: usize, order: Ordering) -> usize`

Subtract from the current usize, returning the previous value.

# Examples

fn main() { use std::sync::atomic::{AtomicUsize, Ordering}; let foo = AtomicUsize::new(10); assert_eq!(foo.fetch_sub(10, Ordering::SeqCst), 10); assert_eq!(foo.load(Ordering::SeqCst), 0); }

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

    let foo = AtomicUsize::new(10);
    assert_eq!(foo.fetch_sub(10, Ordering::SeqCst), 10);
    assert_eq!(foo.load(Ordering::SeqCst), 0);

#### `fn fetch_and(&self, val: usize, order: Ordering) -> usize`

Bitwise and with the current usize, returning the previous value.

# Examples

fn main() { use std::sync::atomic::{AtomicUsize, Ordering}; let foo = AtomicUsize::new(0b101101); assert_eq!(foo.fetch_and(0b110011, Ordering::SeqCst), 0b101101); assert_eq!(foo.load(Ordering::SeqCst), 0b100001); }

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

    let foo = AtomicUsize::new(0b101101);
    assert_eq!(foo.fetch_and(0b110011, Ordering::SeqCst), 0b101101);
    assert_eq!(foo.load(Ordering::SeqCst), 0b100001);

#### `fn fetch_or(&self, val: usize, order: Ordering) -> usize`

Bitwise or with the current usize, returning the previous value.

# Examples

fn main() { use std::sync::atomic::{AtomicUsize, Ordering}; let foo = AtomicUsize::new(0b101101); assert_eq!(foo.fetch_or(0b110011, Ordering::SeqCst), 0b101101); assert_eq!(foo.load(Ordering::SeqCst), 0b111111); }

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

    let foo = AtomicUsize::new(0b101101);
    assert_eq!(foo.fetch_or(0b110011, Ordering::SeqCst), 0b101101);
    assert_eq!(foo.load(Ordering::SeqCst), 0b111111);

#### `fn fetch_xor(&self, val: usize, order: Ordering) -> usize`

Bitwise xor with the current usize, returning the previous value.

# Examples

fn main() { use std::sync::atomic::{AtomicUsize, Ordering}; let foo = AtomicUsize::new(0b101101); assert_eq!(foo.fetch_xor(0b110011, Ordering::SeqCst), 0b101101); assert_eq!(foo.load(Ordering::SeqCst), 0b011110); }

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

    let foo = AtomicUsize::new(0b101101);
    assert_eq!(foo.fetch_xor(0b110011, Ordering::SeqCst), 0b101101);
    assert_eq!(foo.load(Ordering::SeqCst), 0b011110);

## Trait Implementations

### `impl Default for AtomicUsize`

#### `fn default() -> Self`

### `impl Sync for AtomicUsize`

### `impl Debug for AtomicUsize`

#### `fn fmt(&self, f: &mut Formatter) -> Result`

# 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`)