impl<T> Mutex<T>

const fn new(t: T) -> Mutex<T>

Creates a new mutex in an unlocked state ready for use.

Examples

#![feature(nonpoison_mutex)]

use std::sync::nonpoison::Mutex;

let mutex = Mutex::new(0);

fn get_cloned(self: &Self) -> T
where
    T: Clone

Returns the contained value by cloning it.

Examples

#![feature(nonpoison_mutex)]
#![feature(lock_value_accessors)]

use std::sync::nonpoison::Mutex;

let mut mutex = Mutex::new(7);

assert_eq!(mutex.get_cloned(), 7);

fn set(self: &Self, value: T)

Sets the contained value.

Examples

#![feature(nonpoison_mutex)]
#![feature(lock_value_accessors)]

use std::sync::nonpoison::Mutex;

let mut mutex = Mutex::new(7);

assert_eq!(mutex.get_cloned(), 7);
mutex.set(11);
assert_eq!(mutex.get_cloned(), 11);

fn replace(self: &Self, value: T) -> T

Replaces the contained value with value, and returns the old contained value.

Examples

#![feature(nonpoison_mutex)]
#![feature(lock_value_accessors)]

use std::sync::nonpoison::Mutex;

let mut mutex = Mutex::new(7);

assert_eq!(mutex.replace(11), 7);
assert_eq!(mutex.get_cloned(), 11);

impl<T: ?Sized> Mutex<T>

fn lock(self: &Self) -> MutexGuard<'_, T>

Acquires a mutex, blocking the current thread until it is able to do so.

This function will block the local thread until it is available to acquire the mutex. Upon returning, the thread is the only thread with the lock held. An RAII guard is returned to allow scoped unlock of the lock. When the guard goes out of scope, the mutex will be unlocked.

The exact behavior on locking a mutex in the thread which already holds the lock is left unspecified. However, this function will not return on the second call (it might panic or deadlock, for example).

Panics

This function might panic when called if the lock is already held by the current thread.

Examples

#![feature(nonpoison_mutex)]

use std::sync::{Arc, nonpoison::Mutex};
use std::thread;

let mutex = Arc::new(Mutex::new(0));
let c_mutex = Arc::clone(&mutex);

thread::spawn(move || {
    *c_mutex.lock() = 10;
}).join().expect("thread::spawn failed");
assert_eq!(*mutex.lock(), 10);

fn try_lock(self: &Self) -> TryLockResult<MutexGuard<'_, T>>

Attempts to acquire this lock.

This function does not block. If the lock could not be acquired at this time, then WouldBlock is returned. Otherwise, an RAII guard is returned.

The lock will be unlocked when the guard is dropped.

Errors

If the mutex could not be acquired because it is already locked, then this call will return the WouldBlock error.

Examples

use std::sync::{Arc, Mutex};
use std::thread;

let mutex = Arc::new(Mutex::new(0));
let c_mutex = Arc::clone(&mutex);

thread::spawn(move || {
    let mut lock = c_mutex.try_lock();
    if let Ok(ref mut mutex) = lock {
        **mutex = 10;
    } else {
        println!("try_lock failed");
    }
}).join().expect("thread::spawn failed");
assert_eq!(*mutex.lock().unwrap(), 10);

fn into_inner(self: Self) -> T
where
    T: Sized

Consumes this mutex, returning the underlying data.

Examples

#![feature(nonpoison_mutex)]

use std::sync::nonpoison::Mutex;

let mutex = Mutex::new(0);
assert_eq!(mutex.into_inner(), 0);

fn get_mut(self: &mut Self) -> &mut T

Returns a mutable reference to the underlying data.

Since this call borrows the Mutex mutably, no actual locking needs to take place -- the mutable borrow statically guarantees no locks exist.

Examples

#![feature(nonpoison_mutex)]

use std::sync::nonpoison::Mutex;

let mut mutex = Mutex::new(0);
*mutex.get_mut() = 10;
assert_eq!(*mutex.lock(), 10);

const fn data_ptr(self: &Self) -> *mut T

Returns a raw pointer to the underlying data.

The returned pointer is always non-null and properly aligned, but it is the user's responsibility to ensure that any reads and writes through it are properly synchronized to avoid data races, and that it is not read or written through after the mutex is dropped.

fn with_mut<F, R>(self: &Self, f: F) -> R
where
    F: FnOnce(&mut T) -> R

Acquires the mutex and provides mutable access to the underlying data by passing a mutable reference to the given closure.

This method acquires the lock, calls the provided closure with a mutable reference to the data, and returns the result of the closure. The lock is released after the closure completes, even if it panics.

Examples

#![feature(lock_value_accessors, nonpoison_mutex)]

use std::sync::nonpoison::Mutex;

let mutex = Mutex::new(2);

let result = mutex.with_mut(|data| {
    *data += 3;

    *data + 5
});

assert_eq!(*mutex.lock(), 5);
assert_eq!(result, 10);

impl<T> Any for Mutex<T>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Mutex<T>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for Mutex<T>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> Freeze for Mutex<T>

impl<T> From for Mutex<T>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> From for Mutex<T>

fn from(t: never) -> T

impl<T> From for Mutex<T>

fn from(t: T) -> Self

Creates a new mutex in an unlocked state ready for use. This is equivalent to Mutex::new.

impl<T> RefUnwindSafe for Mutex<T>

impl<T> Unpin for Mutex<T>

impl<T> UnsafeUnpin for Mutex<T>

impl<T> UnwindSafe for Mutex<T>

impl<T, U> Into for Mutex<T>

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for Mutex<T>

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for Mutex<T>

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>

impl<T: ?Sized + Send> Send for Mutex<T>

impl<T: ?Sized + Send> Sync for Mutex<T>

impl<T: ?Sized + fmt::Debug> Debug for Mutex<T>

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

impl<T: Default> Default for Mutex<T>

fn default() -> Mutex<T>

Creates a Mutex<T>, with the Default value for T.