std::sync::atomic::AtomicPtr
Struct std::sync::atomic::AtomicPtr
pub struct AtomicPtr<T> { /* fields omitted */ }
A raw pointer type which can be safely shared between threads.
This type has the same in-memory representation as a *mut T
.
Methods
impl<T> AtomicPtr<T>
[src]
const fn new(p: *mut T) -> AtomicPtr<T>
Creates a new AtomicPtr
.
Examples
use std::sync::atomic::AtomicPtr; let ptr = &mut 5; let atomic_ptr = AtomicPtr::new(ptr);
fn get_mut(&mut self) -> &mut *mut T
1.15.0
Returns a mutable reference to the underlying pointer.
This is safe because the mutable reference guarantees that no other threads are concurrently accessing the atomic data.
Examples
use std::sync::atomic::{AtomicPtr, Ordering}; let mut atomic_ptr = AtomicPtr::new(&mut 10); *atomic_ptr.get_mut() = &mut 5; assert_eq!(unsafe { *atomic_ptr.load(Ordering::SeqCst) }, 5);
fn into_inner(self) -> *mut T
1.15.0
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::AtomicPtr; let atomic_ptr = AtomicPtr::new(&mut 5); assert_eq!(unsafe { *atomic_ptr.into_inner() }, 5);
fn load(&self, order: Ordering) -> *mut T
Loads a value from the pointer.
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::{AtomicPtr, Ordering}; let ptr = &mut 5; let some_ptr = AtomicPtr::new(ptr); let value = some_ptr.load(Ordering::Relaxed);
fn store(&self, ptr: *mut T, order: Ordering)
Stores a value into the pointer.
store
takes an Ordering
argument which describes the memory ordering of this operation-
Examples
use std::sync::atomic::{AtomicPtr, Ordering}; let ptr = &mut 5; let some_ptr = AtomicPtr::new(ptr); let other_ptr = &mut 10; some_ptr.store(other_ptr, Ordering::Relaxed);
Panics
fn swap(&self, ptr: *mut T, order: Ordering) -> *mut T
Stores a value into the pointer, returning the previous value.
swap
takes an Ordering
argument which describes the memory ordering of this operation-
Examples
use std::sync::atomic::{AtomicPtr, Ordering}; let ptr = &mut 5; let some_ptr = AtomicPtr::new(ptr); let other_ptr = &mut 10; let value = some_ptr.swap(other_ptr, Ordering::Relaxed);
fn compare_and_swap(
&self,
current: *mut T,
new: *mut T,
order: Ordering
) -> *mut T
&self,
current: *mut T,
new: *mut T,
order: Ordering
) -> *mut T
Stores a value into the pointer 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::{AtomicPtr, Ordering}; let ptr = &mut 5; let some_ptr = AtomicPtr::new(ptr); let other_ptr = &mut 10; let another_ptr = &mut 10; let value = some_ptr.compare_and_swap(other_ptr, another_ptr, Ordering::Relaxed);
fn compare_exchange(
&self,
current: *mut T,
new: *mut T,
success: Ordering,
failure: Ordering
) -> Result<*mut T, *mut T>
1.10.0
&self,
current: *mut T,
new: *mut T,
success: Ordering,
failure: Ordering
) -> Result<*mut T, *mut T>
Stores a value into the pointer 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::{AtomicPtr, Ordering}; let ptr = &mut 5; let some_ptr = AtomicPtr::new(ptr); let other_ptr = &mut 10; let another_ptr = &mut 10; let value = some_ptr.compare_exchange(other_ptr, another_ptr, Ordering::SeqCst, Ordering::Relaxed);
fn compare_exchange_weak(
&self,
current: *mut T,
new: *mut T,
success: Ordering,
failure: Ordering
) -> Result<*mut T, *mut T>
1.10.0
&self,
current: *mut T,
new: *mut T,
success: Ordering,
failure: Ordering
) -> Result<*mut T, *mut T>
Stores a value into the pointer 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::{AtomicPtr, Ordering}; let some_ptr = AtomicPtr::new(&mut 5); let new = &mut 10; let mut old = some_ptr.load(Ordering::Relaxed); loop { match some_ptr.compare_exchange_weak(old, new, Ordering::SeqCst, Ordering::Relaxed) { Ok(_) => break, Err(x) => old = x, } }
Trait Implementations
impl<T> Default for AtomicPtr<T>
[src]
fn default() -> AtomicPtr<T>
Creates a null AtomicPtr<T>
.
impl<T> Send for AtomicPtr<T>
[src]
impl<T> Debug for AtomicPtr<T>
1.3.0
[src]
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
Formats the value using the given formatter.
impl<T> Sync for AtomicPtr<T>
[src]
impl<T> RefUnwindSafe for AtomicPtr<T>
1.14.0
[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.AtomicPtr.html