Struct AssumeUnlockable

pub struct AssumeUnlockable;

WARNING: AssumeUnlockable may cause undefined behaviour without unsafe code!

A dummy RawMutex implementation to skip synchronization on single threaded systems.

Safety

AssumeUnlockable is highly unsafe and may cause undefined behaviour if multiple threads enter a critical section it guards, even without explicit unsafe code.

Note that uncontended spin locks are cheap. Usage is only recommended on platforms that don’t have atomics or are exclusively single threaded.

Through no fault of its own, lock_api’s API does not allow for safe encapsulation of this functionality. This is a hack for backwards compatibility.

Trait Implementations

impl RawMutex for AssumeUnlockable

const INIT: AssumeUnlockable = AssumeUnlockable

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.