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

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

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> GetStaticEquivalent_ for RMutex<T> where
    T: __StableAbi, 

type StaticEquivalent = _static_RMutex<__GetStaticEquivalent<T>>

impl<T: Send> Send for RMutex<T> where
    RawMutex: Send, 

impl<T> StableAbi for RMutex<T> where
    T: __StableAbi, 

type IsNonZeroType = False

Whether this type has a single invalid bit-pattern.

pub const LAYOUT: &'static TypeLayout

The layout of the type provided by implementors.

pub const ABI_CONSTS: AbiConsts

const-equivalents of the associated types.

impl<T: Send> Sync for RMutex<T> where
    RawMutex: Sync,