pub struct Mutex<T: ?Sized> { /* fields omitted */ }
A mutual exclusion primitive useful for protecting shared data
This mutex will block threads waiting for the lock to become available. The
mutex can also be statically initialized or created via a new
constructor. Each mutex has a type parameter which represents the data that
it is protecting. The data can only be accessed through the RAII guards
returned from lock
and try_lock
, which guarantees that the data is only
ever accessed when the mutex is locked.
The mutexes in this module implement a strategy called "poisoning" where a
mutex is considered poisoned whenever a thread panics while holding the
mutex. Once a mutex is poisoned, all other threads are unable to access the
data by default as it is likely tainted (some invariant is not being
upheld).
For a mutex, this means that the lock
and try_lock
methods return a
Result
which indicates whether a mutex has been poisoned or not. Most
usage of a mutex will simply unwrap()
these results, propagating panics
among threads to ensure that a possibly invalid invariant is not witnessed.
A poisoned mutex, however, does not prevent all access to the underlying
data. The PoisonError
type has an into_inner
method which will return
the guard that would have otherwise been returned on a successful lock. This
allows access to the data, despite the lock being poisoned.
use std::sync::{Arc, Mutex};
use std::thread;
use std::sync::mpsc::channel;
const N: usize = 10;
let data = Arc::new(Mutex::new(0));
let (tx, rx) = channel();
for _ in 0..N {
let (data, tx) = (Arc::clone(&data), tx.clone());
thread::spawn(move || {
let mut data = data.lock().unwrap();
*data += 1;
if *data == N {
tx.send(()).unwrap();
}
});
}
rx.recv().unwrap();Run
To recover from a poisoned mutex:
use std::sync::{Arc, Mutex};
use std::thread;
let lock = Arc::new(Mutex::new(0_u32));
let lock2 = lock.clone();
let _ = thread::spawn(move || -> () {
let _guard = lock2.lock().unwrap();
panic!();
}).join();
let mut guard = match lock.lock() {
Ok(guard) => guard,
Err(poisoned) => poisoned.into_inner(),
};
*guard += 1;Run
Creates a new mutex in an unlocked state ready for use.
use std::sync::Mutex;
let mutex = Mutex::new(0);Run
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).
If another user of this mutex panicked while holding the mutex, then
this call will return an error once the mutex is acquired.
This function might panic when called if the lock is already held by
the current thread.
use std::sync::{Arc, Mutex};
use std::thread;
let mutex = Arc::new(Mutex::new(0));
let c_mutex = mutex.clone();
thread::spawn(move || {
*c_mutex.lock().unwrap() = 10;
}).join().expect("thread::spawn failed");
assert_eq!(*mutex.lock().unwrap(), 10);Run
Attempts to acquire this lock.
If the lock could not be acquired at this time, then Err
is returned.
Otherwise, an RAII guard is returned. The lock will be unlocked when the
guard is dropped.
This function does not block.
If another user of this mutex panicked while holding the mutex, then
this call will return failure if the mutex would otherwise be
acquired.
use std::sync::{Arc, Mutex};
use std::thread;
let mutex = Arc::new(Mutex::new(0));
let c_mutex = mutex.clone();
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);Run
Determines whether the mutex is poisoned.
If another thread is active, the mutex can still become poisoned at any
time. You should not trust a false
value for program correctness
without additional synchronization.
use std::sync::{Arc, Mutex};
use std::thread;
let mutex = Arc::new(Mutex::new(0));
let c_mutex = mutex.clone();
let _ = thread::spawn(move || {
let _lock = c_mutex.lock().unwrap();
panic!();
}).join();
assert_eq!(mutex.is_poisoned(), true);Run
Consumes this mutex, returning the underlying data.
If another user of this mutex panicked while holding the mutex, then
this call will return an error instead.
use std::sync::Mutex;
let mutex = Mutex::new(0);
assert_eq!(mutex.into_inner().unwrap(), 0);Run
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.
If another user of this mutex panicked while holding the mutex, then
this call will return an error instead.
use std::sync::Mutex;
let mut mutex = Mutex::new(0);
*mutex.get_mut().unwrap() = 10;
assert_eq!(*mutex.lock().unwrap(), 10);Run
Formats the value using the given formatter. Read more
Creates a new mutex in an unlocked state ready for use.
This is equivalent to Mutex::new
.
Executes the destructor for this type. Read more
Creates a Mutex<T>
, with the Default
value for T.
🔬 This is a nightly-only experimental API. (
try_from
#33417)
The type returned in the event of a conversion error.
🔬 This is a nightly-only experimental API. (
try_from
#33417)
🔬 This is a nightly-only experimental API. (
try_from
#33417)
The type returned in the event of a conversion error.
🔬 This is a nightly-only experimental API. (
try_from
#33417)
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more
🔬 This is a nightly-only experimental API. (get_type_id
#27745)
this method will likely be replaced by an associated static