Struct safe_lock::SafeLock

pub struct SafeLock { /* fields omitted */ }

A lock.

See lock.

This is not a fair lock. If multiple threads acquire the lock in loops, some may never acquire it.

Example

Make some tests run sequentially so they don’t interfere with each other:

use safe_lock::SafeLock;
static LOCK: SafeLock = SafeLock::new();

[#test]
fn test1() {
    let _guard = LOCK.lock();
    // ...
}

[#test]
fn test2() {
    let _guard = LOCK.lock();
    // ...
}

Implementations

impl SafeLock

#[must_use]pub const fn new() -> SafeLock

#[must_use]pub fn lock(&self) -> Option<SafeLockGuard<'_>>

Waits until the lock is free, then acquires the lock.

Multiple threads can call lock but only one will acquire the lock and return.

Drop the returned SafeLockGuard to release the lock.

This is not a fair lock. If multiple threads acquire the lock in loops, some may never acquire it.

Uses Ordering::Acquire to acquire the lock and Ordering::Release to release it, so the lock orders operations on other atomic values.

Trait Implementations

impl Default for SafeLock

fn default() -> Self

Returns the “default value” for a type.