Struct RawOneShotMutex

pub struct RawOneShotMutex { /* private fields */ }

A one-shot mutex that panics instead of (dead)locking on contention.

This mutex allows no contention and panics instead of blocking on lock if it is already locked. This is useful in situations where contention would be a bug, such as in single-threaded programs that would deadlock on contention.

This mutex should be used through OneShotMutex.

Examples

use one_shot_mutex::sync::OneShotMutex;

static X: OneShotMutex<i32> = OneShotMutex::new(42);

// This is equivalent to `X.try_lock().unwrap()`.
let x = X.lock();

// This panics instead of deadlocking.
// let x2 = X.lock();

// Once we unlock the mutex, we can lock it again.
drop(x);
let x = X.lock();

Implementations

impl RawOneShotMutex

pub const fn new() -> Self

Trait Implementations

impl Default for RawOneShotMutex

fn default() -> Self

Returns the “default value” for a type.

impl RawMutex for RawOneShotMutex

const INIT: Self

Initial value for an unlocked mutex.

type GuardMarker = GuardSend

Marker type which determines whether a lock guard should be Send. Use one of the GuardSend or GuardNoSend helper types here.

fn lock(&self)

Acquires this mutex, blocking the current thread until it is able to do so.

fn try_lock(&self) -> bool

Attempts to acquire this mutex without blocking. Returns true if the lock was successfully acquired and false otherwise.

unsafe fn unlock(&self)

Unlocks this mutex.

fn is_locked(&self) -> bool

Checks whether the mutex is currently locked.

impl RawMutexFair for RawOneShotMutex

unsafe fn unlock_fair(&self)

Unlocks this mutex using a fair unlock protocol.

unsafe fn bump(&self)

Temporarily yields the mutex to a waiting thread if there is one.