Struct AtomicArc

pub struct AtomicArc<T>(/* private fields */);

An atomic pointer for 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(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

Creates a AtomicArc with the value.

pub fn load(&self, order: Ordering) -> 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.

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

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

pub fn compare_exchange( &self, current: &Arc<T>, new: &Arc<T>, success: Ordering, failure: Ordering, ) -> Result<Arc<T>, Arc<T>>

Stores an Arc into the pointer if the current value is the same as current.