Struct RacyLock 

pub struct RacyLock<T, F = fn() -> T>
where
    F: Fn() -> T,
{ /* private fields */ }

Thread-safe, non-blocking, lazily evaluated lock with the same interface as std::sync::LazyLock.

Concurrent threads will race to set the value atomically, and memory allocated by losing threads will be dropped immediately after they fail to set the pointer.

The underlying implementation is based on once_cell::race::OnceBox which relies on core::sync::atomic::AtomicPtr to ensure that the data race results in a single successful write to the relevant pointer, namely the first write. See https://github.com/matklad/once_cell/blob/v1.19.0/src/race.rs#L294.

Performs lazy evaluation and can be used for statics.

Implementations

impl<T, F> RacyLock<T, F>

where F: Fn() -> T,

pub const fn new(f: F) -> RacyLock<T, F>

Creates a new lazy, racy value with the given initializing function.

pub fn force(this: &RacyLock<T, F>) -> &T

Forces the evaluation of the locked value and returns a reference to the result. This is equivalent to the Self::deref.

There is no blocking involved in this operation. Instead, concurrent threads will race to set the underlying pointer. Memory allocated by losing threads will be dropped immediately after they fail to set the pointer.

This function’s interface is designed around std::sync::LazyLock::force but the implementation is derived from once_cell::race::OnceBox::get_or_try_init.

Trait Implementations

impl<T, F> Debug for RacyLock<T, F>

where T: Debug, F: Fn() -> T,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Default for RacyLock<T>

where T: Default,

fn default() -> RacyLock<T>

Creates a new lock that will evaluate the underlying value based on T::default.

impl<T, F> Deref for RacyLock<T, F>

where F: Fn() -> T,

fn deref(&self) -> &T

Either sets or retrieves the value, and dereferences it.

See Self::force for more details.

type Target = T

The resulting type after dereferencing.

impl<T, F> Drop for RacyLock<T, F>

where F: Fn() -> T,

fn drop(&mut self)

Drops the underlying pointer.