Struct abi_stable::external_types::parking_lot::mutex::RMutex

#[repr(C)]
pub struct RMutex<T> { /* private fields */ }

A mutual exclusion lock that allows dynamic mutable borrows of shared data.

Poisoning

As opposed to the standard library version of this type, this mutex type does not use poisoning, simply unlocking the lock when a panic happens.

Example

use abi_stable::external_types::RMutex;

static MUTEX: RMutex<usize> = RMutex::new(0);

let guard = std::thread::spawn(|| {
    for _ in 0..100 {
        *MUTEX.lock() += 1;
    }
});

for _ in 0..100 {
    *MUTEX.lock() += 1;
}

guard.join().unwrap();

assert_eq!(*MUTEX.lock(), 200);

Implementations

impl<T> RMutex<T>

pub const fn new(value: T) -> Self

Constructs a mutex,wrapping value.

Example

use abi_stable::external_types::RMutex;

static MUTEX: RMutex<Option<String>> = RMutex::new(None);

let mutex = RMutex::new(0);

pub fn into_inner(self) -> T

Unwraps this mutex into its wrapped data.

Example

use abi_stable::external_types::RMutex;

let mutex = RMutex::new("hello".to_string());

assert_eq!(mutex.into_inner().as_str(), "hello");

pub fn get_mut(&mut self) -> &mut T

Gets a mutable reference to its wrapped data.

This does not require any locking,since it takes self mutably.

Example

use abi_stable::external_types::RMutex;

let mut mutex = RMutex::new("Hello".to_string());

mutex.get_mut().push_str(", World!");

assert_eq!(mutex.lock().as_str(), "Hello, World!");

pub fn lock(&self) -> RMutexGuard<'_, T>

Acquires a mutex,blocking the current thread until it can.

This function returns a guard which releases the mutex when it is dropped.

Trying to lock the mutex in the same thread that holds the lock will cause a deadlock.

Example

use abi_stable::external_types::RMutex;

static MUTEX: RMutex<usize> = RMutex::new(0);

let guard = std::thread::spawn(|| *MUTEX.lock() += 1);

*MUTEX.lock() += 4;

guard.join().unwrap();

assert_eq!(*MUTEX.lock(), 5);

pub fn try_lock(&self) -> ROption<RMutexGuard<'_, T>>

Attemps to acquire a mutex guard.

Returns the mutex guard if the mutex can be immediately acquired, otherwise returns RNone.

Example

use abi_stable::external_types::RMutex;

static MUTEX: RMutex<usize> = RMutex::new(0);

let mut guard = MUTEX.try_lock().unwrap();

assert!(MUTEX.try_lock().is_none());

assert_eq!(*guard, 0);

pub fn try_lock_for(&self, timeout: RDuration) -> ROption<RMutexGuard<'_, T>>

Attempts to acquire a mutex guard for the timeout duration.

Once the timeout is reached,this will return RNone, otherwise it will return the mutex guard.

Example

use abi_stable::{external_types::RMutex, std_types::RDuration};

static MUTEX: RMutex<usize> = RMutex::new(0);

static DUR: RDuration = RDuration::from_millis(4);

let mut guard = MUTEX.try_lock_for(DUR).unwrap();

assert!(MUTEX.try_lock_for(DUR).is_none());

assert_eq!(*guard, 0);

Trait Implementations

impl<T: Default> Default for RMutex<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> GetStaticEquivalent_ for RMutex<T>

where T: __StableAbi,

type StaticEquivalent = _static_RMutex<<T as GetStaticEquivalent_>::StaticEquivalent>

The 'static equivalent of Self

impl<T> StableAbi for RMutex<T>

where T: __StableAbi,

type IsNonZeroType = False

Whether this type has a single invalid bit-pattern.

const LAYOUT: &'static TypeLayout = _

The layout of the type provided by implementors.

const ABI_CONSTS: AbiConsts = _

const-equivalents of the associated types.

impl<T: Send> Send for RMutex<T>

where RawMutex: Send,

impl<T: Send> Sync for RMutex<T>

where RawMutex: Sync,