Struct AtomicArc

pub struct AtomicArc<T> { /* private fields */ }

A lightweight atomic pointer to Arc.

Note: The imlementation manipuates the internal reference count of the original Arc for optimization. This means that the result of Arc::strong_count is incorrect, until the Arc gets rid of this pointer’s control (with AtomicArc::swap). Users who depend on the correctness of Arc::strong_count should be careful.

Limitations

The implementation borrows some bits from the Arc pointer as an external reference count (a technique called “split reference counting”). It will panic in some extreame scenario when the reference count is increased more than a threshold (2^15) at the same time. This is almost impossible unless someone creates more than 2^15 threads to load the same pointer at the same time.

Examples

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

use atomic_ext::AtomicArc;

let a = Arc::new(1);
let b = Arc::new(2);
let x = Arc::new(AtomicArc::new(a));
{
    let x = x.clone();
    thread::spawn(move || {
        x.swap(Some(b), Ordering::AcqRel) // Returns `a`
    });
}
{
    let x = x.clone();
    thread::spawn(move || {
        x.load(Ordering::Acquire) // Returns either `a` or `b`
    });
};

Implementations

impl<T> AtomicArc<T>

pub fn new(value: Arc<T>) -> Self

Constructs a new AtomicArc.

pub fn load(&self, order: Ordering) -> Option<Arc<T>>

Loads an Arc from the pointer.

The fast path uses just one atomic operation to load the Arc and increase its reference count.

Returns None if the pointer is null.

pub fn swap(&self, value: Option<Arc<T>>, order: Ordering) -> Option<Arc<T>>

Stores an Arc into the pointer, returning the previous value.

Trait Implementations

impl<T> Default for AtomicArc<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Drop for AtomicArc<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Send for AtomicArc<T>

impl<T> Sync for AtomicArc<T>