std::sync::atomic::AtomicU8
Struct std::sync::atomic::AtomicU8
pub struct AtomicU8 { /* fields omitted */ }
An integer type which can be safely shared between threads.
This type has the same in-memory representation as the underlying integer type.
Methods
impl AtomicU8
[src]
const fn new(v: u8) -> AtomicU8
Creates a new atomic integer.
Examples
use std::sync::atomic::AtomicIsize; let atomic_forty_two = AtomicIsize::new(42);
fn get_mut(&mut self) -> &mut u8
Returns a mutable reference to the underlying integer.
This is safe because the mutable reference guarantees that no other threads are concurrently accessing the atomic data.
Examples
use std::sync::atomic::{AtomicIsize, Ordering}; let mut some_isize = AtomicIsize::new(10); assert_eq!(*some_isize.get_mut(), 10); *some_isize.get_mut() = 5; assert_eq!(some_isize.load(Ordering::SeqCst), 5);
fn into_inner(self) -> u8
Consumes the atomic and returns the contained value.
This is safe because passing self
by value guarantees that no other threads are concurrently accessing the atomic data.
Examples
use std::sync::atomic::AtomicIsize; let some_isize = AtomicIsize::new(5); assert_eq!(some_isize.into_inner(), 5);
fn load(&self, order: Ordering) -> u8
Loads a value from the atomic integer.
load
takes an Ordering
argument which describes the memory ordering of this operation-
Panics
Panics if order
is Release
or AcqRel
.
Examples
use std::sync::atomic::{AtomicIsize, Ordering}; let some_isize = AtomicIsize::new(5); assert_eq!(some_isize.load(Ordering::Relaxed), 5);
fn store(&self, val: u8, order: Ordering)
Stores a value into the atomic integer.
store
takes an Ordering
argument which describes the memory ordering of this operation-
Examples
use std::sync::atomic::{AtomicIsize, Ordering}; let some_isize = AtomicIsize::new(5); some_isize.store(10, Ordering::Relaxed); assert_eq!(some_isize.load(Ordering::Relaxed), 10);
Panics
fn swap(&self, val: u8, order: Ordering) -> u8
Stores a value into the atomic integer, returning the previous value.
swap
takes an Ordering
argument which describes the memory ordering of this operation-
Examples
use std::sync::atomic::{AtomicIsize, Ordering}; let some_isize = AtomicIsize::new(5); assert_eq!(some_isize.swap(10, Ordering::Relaxed), 5);
fn compare_and_swap(&self, current: u8, new: u8, order: Ordering) -> u8
Stores a value into the atomic integer 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
use std::sync::atomic::{AtomicIsize, Ordering}; let some_isize = AtomicIsize::new(5); assert_eq!(some_isize.compare_and_swap(5, 10, Ordering::Relaxed), 5); assert_eq!(some_isize.load(Ordering::Relaxed), 10); assert_eq!(some_isize.compare_and_swap(6, 12, Ordering::Relaxed), 10); assert_eq!(some_isize.load(Ordering::Relaxed), 10);
fn compare_exchange(
&self,
current: u8,
new: u8,
success: Ordering,
failure: Ordering
) -> Result<u8, u8>
&self,
current: u8,
new: u8,
success: Ordering,
failure: Ordering
) -> Result<u8, u8>
Stores a value into the atomic integer if the current value is the same as the current
value.
The return value is a result indicating whether the new value was written and containing the previous value. On success this value is guaranteed to be equal to current
.
compare_exchange
takes two Ordering
arguments to describe the memory ordering of this operation- The first describes the required ordering if the operation succeeds while the second describes the required ordering when the operation fails- The failure ordering can't be Release
or AcqRel
and must be equivalent or weaker than the success ordering.
Examples
use std::sync::atomic::{AtomicIsize, Ordering}; let some_isize = AtomicIsize::new(5); assert_eq!(some_isize.compare_exchange(5, 10, Ordering::Acquire, Ordering::Relaxed), Ok(5)); assert_eq!(some_isize.load(Ordering::Relaxed), 10); assert_eq!(some_isize.compare_exchange(6, 12, Ordering::SeqCst, Ordering::Acquire), Err(10)); assert_eq!(some_isize.load(Ordering::Relaxed), 10);
fn compare_exchange_weak(
&self,
current: u8,
new: u8,
success: Ordering,
failure: Ordering
) -> Result<u8, u8>
&self,
current: u8,
new: u8,
success: Ordering,
failure: Ordering
) -> Result<u8, u8>
Stores a value into the atomic integer if the current value is the same as the current
value.
Unlike compare_exchange
, this function is allowed to spuriously fail even when the comparison succeeds, which can result in more efficient code on some platforms. The return value is a result indicating whether the new value was written and containing the previous value.
compare_exchange_weak
takes two Ordering
arguments to describe the memory ordering of this operation- The first describes the required ordering if the operation succeeds while the second describes the required ordering when the operation fails- The failure ordering can't be Release
or AcqRel
and must be equivalent or weaker than the success ordering.
Examples
use std::sync::atomic::{AtomicIsize, Ordering}; let val = AtomicIsize::new(4); let mut old = val.load(Ordering::Relaxed); loop { let new = old * 2; match val.compare_exchange_weak(old, new, Ordering::SeqCst, Ordering::Relaxed) { Ok(_) => break, Err(x) => old = x, } }
fn fetch_add(&self, val: u8, order: Ordering) -> u8
Adds to the current value, returning the previous value.
This operation wraps around on overflow.
Examples
use std::sync::atomic::{AtomicIsize, Ordering}; let foo = AtomicIsize::new(0); assert_eq!(foo.fetch_add(10, Ordering::SeqCst), 0); assert_eq!(foo.load(Ordering::SeqCst), 10);
fn fetch_sub(&self, val: u8, order: Ordering) -> u8
Subtracts from the current value, returning the previous value.
This operation wraps around on overflow.
Examples
use std::sync::atomic::{AtomicIsize, Ordering}; let foo = AtomicIsize::new(0); assert_eq!(foo.fetch_sub(10, Ordering::SeqCst), 0); assert_eq!(foo.load(Ordering::SeqCst), -10);
fn fetch_and(&self, val: u8, order: Ordering) -> u8
Bitwise "and" with the current value.
Performs a bitwise "and" operation on the current value and the argument val
, and sets the new value to the result.
Returns the previous value.
Examples
use std::sync::atomic::{AtomicIsize, Ordering}; let foo = AtomicIsize::new(0b101101); assert_eq!(foo.fetch_and(0b110011, Ordering::SeqCst), 0b101101); assert_eq!(foo.load(Ordering::SeqCst), 0b100001);
fn fetch_or(&self, val: u8, order: Ordering) -> u8
Bitwise "or" with the current value.
Performs a bitwise "or" operation on the current value and the argument val
, and sets the new value to the result.
Returns the previous value.
Examples
use std::sync::atomic::{AtomicIsize, Ordering}; let foo = AtomicIsize::new(0b101101); assert_eq!(foo.fetch_or(0b110011, Ordering::SeqCst), 0b101101); assert_eq!(foo.load(Ordering::SeqCst), 0b111111);
fn fetch_xor(&self, val: u8, order: Ordering) -> u8
Bitwise "xor" with the current value.
Performs a bitwise "xor" operation on the current value and the argument val
, and sets the new value to the result.
Returns the previous value.
Examples
use std::sync::atomic::{AtomicIsize, Ordering}; let foo = AtomicIsize::new(0b101101); assert_eq!(foo.fetch_xor(0b110011, Ordering::SeqCst), 0b101101); assert_eq!(foo.load(Ordering::SeqCst), 0b011110);
Trait Implementations
impl Default for AtomicU8
[src]
fn default() -> AtomicU8
Returns the "default value" for a type. Read more
impl Debug for AtomicU8
[src]
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
Formats the value using the given formatter.
impl Sync for AtomicU8
[src]
impl RefUnwindSafe for AtomicU8
[src]
© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/sync/atomic/struct.AtomicU8.html