Struct Mutex 

pub struct Mutex<T> { /* private fields */ }

An OptionLock with a guaranteed value.

Implementations

impl<T> Mutex<T>

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

Create a new mutex instance.

Examples found in repository

examples/try-mutex.rs (line 8)

fn main() {
    let shared = Arc::new(Mutex::new(0i32));
    let threads = 100;
    for _ in 0..threads {
        let shared = shared.clone();
        thread::spawn(move || {
            let mut guard = shared.spin_lock().unwrap();
            *guard += 1;
        });
    }
    loop {
        if shared.try_copy() == Ok(threads) {
            break;
        }
        spin_loop()
    }
    println!("Completed {} threads", threads);
}

pub fn is_locked(&self) -> bool

Check if a guard is held.

pub fn is_poisoned(&self) -> bool

Check if the contained value was removed.

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

Get a mutable reference to the contained value

pub fn into_inner(self) -> Result<T, PoisonError>

Unwrap an owned mutex instance.

pub fn try_lock(&self) -> Result<MutexGuard<'_, T>, MutexLockError>

Try to acquire an exclusive lock around the contained value

pub fn try_lock_arc( self: &Arc<Self>, ) -> Result<MutexGuardArc<T>, MutexLockError>

Try to acquire an exclusive lock for an Arc<Mutex>.

pub fn spin_lock(&self) -> Result<MutexGuard<'_, T>, PoisonError>

In a spin loop, wait to acquire the mutex.

Examples found in repository

examples/try-mutex.rs (line 13)

fn main() {
    let shared = Arc::new(Mutex::new(0i32));
    let threads = 100;
    for _ in 0..threads {
        let shared = shared.clone();
        thread::spawn(move || {
            let mut guard = shared.spin_lock().unwrap();
            *guard += 1;
        });
    }
    loop {
        if shared.try_copy() == Ok(threads) {
            break;
        }
        spin_loop()
    }
    println!("Completed {} threads", threads);
}

impl<T: Clone> Mutex<T>

pub fn try_clone(&self) -> Result<T, MutexLockError>

Try to clone the contained resource.

impl<T: Copy> Mutex<T>

pub fn try_copy(&self) -> Result<T, MutexLockError>

Try to copy the contained resource.

On successful acquisition Some(T) is returned. If the lock is currently held or the value is empty, then None is returned.

Examples found in repository

examples/try-mutex.rs (line 18)

fn main() {
    let shared = Arc::new(Mutex::new(0i32));
    let threads = 100;
    for _ in 0..threads {
        let shared = shared.clone();
        thread::spawn(move || {
            let mut guard = shared.spin_lock().unwrap();
            *guard += 1;
        });
    }
    loop {
        if shared.try_copy() == Ok(threads) {
            break;
        }
        spin_loop()
    }
    println!("Completed {} threads", threads);
}

Trait Implementations

impl<T> Debug for Mutex<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> RefUnwindSafe for Mutex<T>

impl<T> UnwindSafe for Mutex<T>