Ronald Kinard
8 years ago
committed by
GitHub
11 changed files with 1286 additions and 5 deletions
@ -0,0 +1,681 @@
@@ -0,0 +1,681 @@
|
||||
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
||||
// file at the top-level directory of this distribution and at
|
||||
// http://rust-lang.org/COPYRIGHT.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use cell::UnsafeCell; |
||||
use fmt; |
||||
use marker; |
||||
use mem; |
||||
use ops::{Deref, DerefMut}; |
||||
use ptr; |
||||
use sys_common::mutex as sys; |
||||
use sys_common::poison::{self, TryLockError, TryLockResult, LockResult}; |
||||
|
||||
/// 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.
|
||||
///
|
||||
/// # Poisoning
|
||||
///
|
||||
/// The mutexes in this module implement a strategy called "poisoning" where a
|
||||
/// mutex is considered poisoned whenever a thread panics while holding the
|
||||
/// lock. 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.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use std::sync::{Arc, Mutex};
|
||||
/// use std::thread;
|
||||
/// use std::sync::mpsc::channel;
|
||||
///
|
||||
/// const N: usize = 10;
|
||||
///
|
||||
/// // Spawn a few threads to increment a shared variable (non-atomically), and
|
||||
/// // let the main thread know once all increments are done.
|
||||
/// //
|
||||
/// // Here we're using an Arc to share memory among threads, and the data inside
|
||||
/// // the Arc is protected with a mutex.
|
||||
/// let data = Arc::new(Mutex::new(0));
|
||||
///
|
||||
/// let (tx, rx) = channel();
|
||||
/// for _ in 0..10 {
|
||||
/// let (data, tx) = (data.clone(), tx.clone());
|
||||
/// thread::spawn(move || {
|
||||
/// // The shared state can only be accessed once the lock is held.
|
||||
/// // Our non-atomic increment is safe because we're the only thread
|
||||
/// // which can access the shared state when the lock is held.
|
||||
/// //
|
||||
/// // We unwrap() the return value to assert that we are not expecting
|
||||
/// // threads to ever fail while holding the lock.
|
||||
/// let mut data = data.lock().unwrap();
|
||||
/// *data += 1;
|
||||
/// if *data == N {
|
||||
/// tx.send(()).unwrap();
|
||||
/// }
|
||||
/// // the lock is unlocked here when `data` goes out of scope.
|
||||
/// });
|
||||
/// }
|
||||
///
|
||||
/// rx.recv().unwrap();
|
||||
/// ```
|
||||
///
|
||||
/// 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 || -> () {
|
||||
/// // This thread will acquire the mutex first, unwrapping the result of
|
||||
/// // `lock` because the lock has not been poisoned.
|
||||
/// let _guard = lock2.lock().unwrap();
|
||||
///
|
||||
/// // This panic while holding the lock (`_guard` is in scope) will poison
|
||||
/// // the mutex.
|
||||
/// panic!();
|
||||
/// }).join();
|
||||
///
|
||||
/// // The lock is poisoned by this point, but the returned result can be
|
||||
/// // pattern matched on to return the underlying guard on both branches.
|
||||
/// let mut guard = match lock.lock() {
|
||||
/// Ok(guard) => guard,
|
||||
/// Err(poisoned) => poisoned.into_inner(),
|
||||
/// };
|
||||
///
|
||||
/// *guard += 1;
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
pub struct Mutex<T: ?Sized> { |
||||
// Note that this mutex is in a *box*, not inlined into the struct itself.
|
||||
// Once a native mutex has been used once, its address can never change (it
|
||||
// can't be moved). This mutex type can be safely moved at any time, so to
|
||||
// ensure that the native mutex is used correctly we box the inner lock to
|
||||
// give it a constant address.
|
||||
inner: Box<sys::Mutex>, |
||||
poison: poison::Flag, |
||||
data: UnsafeCell<T>, |
||||
} |
||||
|
||||
// these are the only places where `T: Send` matters; all other
|
||||
// functionality works fine on a single thread.
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
unsafe impl<T: ?Sized + Send> Send for Mutex<T> { } |
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
unsafe impl<T: ?Sized + Send> Sync for Mutex<T> { } |
||||
|
||||
/// An RAII implementation of a "scoped lock" of a mutex. When this structure is
|
||||
/// dropped (falls out of scope), the lock will be unlocked.
|
||||
///
|
||||
/// The data protected by the mutex can be access through this guard via its
|
||||
/// `Deref` and `DerefMut` implementations.
|
||||
///
|
||||
/// This structure is created by the [`lock()`] and [`try_lock()`] methods on
|
||||
/// [`Mutex`].
|
||||
///
|
||||
/// [`lock()`]: struct.Mutex.html#method.lock
|
||||
/// [`try_lock()`]: struct.Mutex.html#method.try_lock
|
||||
/// [`Mutex`]: struct.Mutex.html
|
||||
#[must_use] |
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
pub struct MutexGuard<'a, T: ?Sized + 'a> { |
||||
// funny underscores due to how Deref/DerefMut currently work (they
|
||||
// disregard field privacy).
|
||||
__lock: &'a Mutex<T>, |
||||
__poison: poison::Guard, |
||||
} |
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
impl<'a, T: ?Sized> !marker::Send for MutexGuard<'a, T> {} |
||||
|
||||
impl<T> Mutex<T> { |
||||
/// Creates a new mutex in an unlocked state ready for use.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use std::sync::Mutex;
|
||||
///
|
||||
/// let mutex = Mutex::new(0);
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
pub fn new(t: T) -> Mutex<T> { |
||||
let mut m = Mutex { |
||||
inner: box sys::Mutex::new(), |
||||
poison: poison::Flag::new(), |
||||
data: UnsafeCell::new(t), |
||||
}; |
||||
unsafe { |
||||
m.inner.init(); |
||||
} |
||||
m |
||||
} |
||||
} |
||||
|
||||
impl<T: ?Sized> Mutex<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 mutex
|
||||
/// 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).
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// If another user of this mutex panicked while holding the mutex, then
|
||||
/// this call will return an error once the mutex is acquired.
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// This function might panic when called if the lock is already held by
|
||||
/// the current thread.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// 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);
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
pub fn lock(&self) -> LockResult<MutexGuard<T>> { |
||||
unsafe { |
||||
self.inner.lock(); |
||||
MutexGuard::new(self) |
||||
} |
||||
} |
||||
|
||||
/// 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.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// If another user of this mutex panicked while holding the mutex, then
|
||||
/// this call will return failure if the mutex would otherwise be
|
||||
/// acquired.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// 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);
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
pub fn try_lock(&self) -> TryLockResult<MutexGuard<T>> { |
||||
unsafe { |
||||
if self.inner.try_lock() { |
||||
Ok(MutexGuard::new(self)?) |
||||
} else { |
||||
Err(TryLockError::WouldBlock) |
||||
} |
||||
} |
||||
} |
||||
|
||||
/// Determines whether the lock is poisoned.
|
||||
///
|
||||
/// If another thread is active, the lock can still become poisoned at any
|
||||
/// time. You should not trust a `false` value for program correctness
|
||||
/// without additional synchronization.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// 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!(); // the mutex gets poisoned
|
||||
/// }).join();
|
||||
/// assert_eq!(mutex.is_poisoned(), true);
|
||||
/// ```
|
||||
#[inline] |
||||
#[stable(feature = "sync_poison", since = "1.2.0")] |
||||
pub fn is_poisoned(&self) -> bool { |
||||
self.poison.get() |
||||
} |
||||
|
||||
/// Consumes this mutex, returning the underlying data.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// If another user of this mutex panicked while holding the mutex, then
|
||||
/// this call will return an error instead.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use std::sync::Mutex;
|
||||
///
|
||||
/// let mutex = Mutex::new(0);
|
||||
/// assert_eq!(mutex.into_inner().unwrap(), 0);
|
||||
/// ```
|
||||
#[stable(feature = "mutex_into_inner", since = "1.6.0")] |
||||
pub fn into_inner(self) -> LockResult<T> where T: Sized { |
||||
// We know statically that there are no outstanding references to
|
||||
// `self` so there's no need to lock the inner lock.
|
||||
//
|
||||
// To get the inner value, we'd like to call `data.into_inner()`,
|
||||
// but because `Mutex` impl-s `Drop`, we can't move out of it, so
|
||||
// we'll have to destructure it manually instead.
|
||||
unsafe { |
||||
// Like `let Mutex { inner, poison, data } = self`.
|
||||
let (inner, poison, data) = { |
||||
let Mutex { ref inner, ref poison, ref data } = self; |
||||
(ptr::read(inner), ptr::read(poison), ptr::read(data)) |
||||
}; |
||||
mem::forget(self); |
||||
inner.destroy(); // Keep in sync with the `Drop` impl.
|
||||
drop(inner); |
||||
|
||||
poison::map_result(poison.borrow(), |_| data.into_inner()) |
||||
} |
||||
} |
||||
|
||||
/// 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.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// If another user of this mutex panicked while holding the mutex, then
|
||||
/// this call will return an error instead.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use std::sync::Mutex;
|
||||
///
|
||||
/// let mut mutex = Mutex::new(0);
|
||||
/// *mutex.get_mut().unwrap() = 10;
|
||||
/// assert_eq!(*mutex.lock().unwrap(), 10);
|
||||
/// ```
|
||||
#[stable(feature = "mutex_get_mut", since = "1.6.0")] |
||||
pub fn get_mut(&mut self) -> LockResult<&mut T> { |
||||
// We know statically that there are no other references to `self`, so
|
||||
// there's no need to lock the inner lock.
|
||||
let data = unsafe { &mut *self.data.get() }; |
||||
poison::map_result(self.poison.borrow(), |_| data ) |
||||
} |
||||
} |
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
unsafe impl<#[may_dangle] T: ?Sized> Drop for Mutex<T> { |
||||
fn drop(&mut self) { |
||||
// This is actually safe b/c we know that there is no further usage of
|
||||
// this mutex (it's up to the user to arrange for a mutex to get
|
||||
// dropped, that's not our job)
|
||||
//
|
||||
// IMPORTANT: This code must be kept in sync with `Mutex::into_inner`.
|
||||
unsafe { self.inner.destroy() } |
||||
} |
||||
} |
||||
|
||||
#[stable(feature = "mutex_default", since = "1.9.0")] |
||||
impl<T: ?Sized + Default> Default for Mutex<T> { |
||||
/// Creates a `Mutex<T>`, with the `Default` value for T.
|
||||
fn default() -> Mutex<T> { |
||||
Mutex::new(Default::default()) |
||||
} |
||||
} |
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
impl<T: ?Sized + fmt::Debug> fmt::Debug for Mutex<T> { |
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
||||
match self.try_lock() { |
||||
Ok(guard) => write!(f, "Mutex {{ data: {:?} }}", &*guard), |
||||
Err(TryLockError::Poisoned(err)) => { |
||||
write!(f, "Mutex {{ data: Poisoned({:?}) }}", &**err.get_ref()) |
||||
}, |
||||
Err(TryLockError::WouldBlock) => write!(f, "Mutex {{ <locked> }}") |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl<'mutex, T: ?Sized> MutexGuard<'mutex, T> { |
||||
unsafe fn new(lock: &'mutex Mutex<T>) -> LockResult<MutexGuard<'mutex, T>> { |
||||
poison::map_result(lock.poison.borrow(), |guard| { |
||||
MutexGuard { |
||||
__lock: lock, |
||||
__poison: guard, |
||||
} |
||||
}) |
||||
} |
||||
} |
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
impl<'mutex, T: ?Sized> Deref for MutexGuard<'mutex, T> { |
||||
type Target = T; |
||||
|
||||
fn deref(&self) -> &T { |
||||
unsafe { &*self.__lock.data.get() } |
||||
} |
||||
} |
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
impl<'mutex, T: ?Sized> DerefMut for MutexGuard<'mutex, T> { |
||||
fn deref_mut(&mut self) -> &mut T { |
||||
unsafe { &mut *self.__lock.data.get() } |
||||
} |
||||
} |
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
impl<'a, T: ?Sized> Drop for MutexGuard<'a, T> { |
||||
#[inline] |
||||
fn drop(&mut self) { |
||||
unsafe { |
||||
self.__lock.poison.done(&self.__poison); |
||||
self.__lock.inner.unlock(); |
||||
} |
||||
} |
||||
} |
||||
|
||||
#[stable(feature = "std_debug", since = "1.16.0")] |
||||
impl<'a, T: ?Sized + fmt::Debug> fmt::Debug for MutexGuard<'a, T> { |
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
||||
f.debug_struct("MutexGuard") |
||||
.field("lock", &self.__lock) |
||||
.finish() |
||||
} |
||||
} |
||||
|
||||
pub fn guard_lock<'a, T: ?Sized>(guard: &MutexGuard<'a, T>) -> &'a sys::Mutex { |
||||
&guard.__lock.inner |
||||
} |
||||
|
||||
pub fn guard_poison<'a, T: ?Sized>(guard: &MutexGuard<'a, T>) -> &'a poison::Flag { |
||||
&guard.__lock.poison |
||||
} |
||||
|
||||
#[cfg(all(test, not(target_os = "emscripten")))] |
||||
mod tests { |
||||
use sync::mpsc::channel; |
||||
use sync::{Arc, Mutex, Condvar}; |
||||
use sync::atomic::{AtomicUsize, Ordering}; |
||||
use thread; |
||||
|
||||
struct Packet<T>(Arc<(Mutex<T>, Condvar)>); |
||||
|
||||
#[derive(Eq, PartialEq, Debug)] |
||||
struct NonCopy(i32); |
||||
|
||||
unsafe impl<T: Send> Send for Packet<T> {} |
||||
unsafe impl<T> Sync for Packet<T> {} |
||||
|
||||
#[test] |
||||
fn smoke() { |
||||
let m = Mutex::new(()); |
||||
drop(m.lock().unwrap()); |
||||
drop(m.lock().unwrap()); |
||||
} |
||||
|
||||
#[test] |
||||
fn lots_and_lots() { |
||||
const J: u32 = 1000; |
||||
const K: u32 = 3; |
||||
|
||||
let m = Arc::new(Mutex::new(0)); |
||||
|
||||
fn inc(m: &Mutex<u32>) { |
||||
for _ in 0..J { |
||||
*m.lock().unwrap() += 1; |
||||
} |
||||
} |
||||
|
||||
let (tx, rx) = channel(); |
||||
for _ in 0..K { |
||||
let tx2 = tx.clone(); |
||||
let m2 = m.clone(); |
||||
thread::spawn(move|| { inc(&m2); tx2.send(()).unwrap(); }); |
||||
let tx2 = tx.clone(); |
||||
let m2 = m.clone(); |
||||
thread::spawn(move|| { inc(&m2); tx2.send(()).unwrap(); }); |
||||
} |
||||
|
||||
drop(tx); |
||||
for _ in 0..2 * K { |
||||
rx.recv().unwrap(); |
||||
} |
||||
assert_eq!(*m.lock().unwrap(), J * K * 2); |
||||
} |
||||
|
||||
#[test] |
||||
fn try_lock() { |
||||
let m = Mutex::new(()); |
||||
*m.try_lock().unwrap() = (); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_into_inner() { |
||||
let m = Mutex::new(NonCopy(10)); |
||||
assert_eq!(m.into_inner().unwrap(), NonCopy(10)); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_into_inner_drop() { |
||||
struct Foo(Arc<AtomicUsize>); |
||||
impl Drop for Foo { |
||||
fn drop(&mut self) { |
||||
self.0.fetch_add(1, Ordering::SeqCst); |
||||
} |
||||
} |
||||
let num_drops = Arc::new(AtomicUsize::new(0)); |
||||
let m = Mutex::new(Foo(num_drops.clone())); |
||||
assert_eq!(num_drops.load(Ordering::SeqCst), 0); |
||||
{ |
||||
let _inner = m.into_inner().unwrap(); |
||||
assert_eq!(num_drops.load(Ordering::SeqCst), 0); |
||||
} |
||||
assert_eq!(num_drops.load(Ordering::SeqCst), 1); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_into_inner_poison() { |
||||
let m = Arc::new(Mutex::new(NonCopy(10))); |
||||
let m2 = m.clone(); |
||||
let _ = thread::spawn(move || { |
||||
let _lock = m2.lock().unwrap(); |
||||
panic!("test panic in inner thread to poison mutex"); |
||||
}).join(); |
||||
|
||||
assert!(m.is_poisoned()); |
||||
match Arc::try_unwrap(m).unwrap().into_inner() { |
||||
Err(e) => assert_eq!(e.into_inner(), NonCopy(10)), |
||||
Ok(x) => panic!("into_inner of poisoned Mutex is Ok: {:?}", x), |
||||
} |
||||
} |
||||
|
||||
#[test] |
||||
fn test_get_mut() { |
||||
let mut m = Mutex::new(NonCopy(10)); |
||||
*m.get_mut().unwrap() = NonCopy(20); |
||||
assert_eq!(m.into_inner().unwrap(), NonCopy(20)); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_get_mut_poison() { |
||||
let m = Arc::new(Mutex::new(NonCopy(10))); |
||||
let m2 = m.clone(); |
||||
let _ = thread::spawn(move || { |
||||
let _lock = m2.lock().unwrap(); |
||||
panic!("test panic in inner thread to poison mutex"); |
||||
}).join(); |
||||
|
||||
assert!(m.is_poisoned()); |
||||
match Arc::try_unwrap(m).unwrap().get_mut() { |
||||
Err(e) => assert_eq!(*e.into_inner(), NonCopy(10)), |
||||
Ok(x) => panic!("get_mut of poisoned Mutex is Ok: {:?}", x), |
||||
} |
||||
} |
||||
|
||||
#[test] |
||||
fn test_mutex_arc_condvar() { |
||||
let packet = Packet(Arc::new((Mutex::new(false), Condvar::new()))); |
||||
let packet2 = Packet(packet.0.clone()); |
||||
let (tx, rx) = channel(); |
||||
let _t = thread::spawn(move|| { |
||||
// wait until parent gets in
|
||||
rx.recv().unwrap(); |
||||
let &(ref lock, ref cvar) = &*packet2.0; |
||||
let mut lock = lock.lock().unwrap(); |
||||
*lock = true; |
||||
cvar.notify_one(); |
||||
}); |
||||
|
||||
let &(ref lock, ref cvar) = &*packet.0; |
||||
let mut lock = lock.lock().unwrap(); |
||||
tx.send(()).unwrap(); |
||||
assert!(!*lock); |
||||
while !*lock { |
||||
lock = cvar.wait(lock).unwrap(); |
||||
} |
||||
} |
||||
|
||||
#[test] |
||||
fn test_arc_condvar_poison() { |
||||
let packet = Packet(Arc::new((Mutex::new(1), Condvar::new()))); |
||||
let packet2 = Packet(packet.0.clone()); |
||||
let (tx, rx) = channel(); |
||||
|
||||
let _t = thread::spawn(move || -> () { |
||||
rx.recv().unwrap(); |
||||
let &(ref lock, ref cvar) = &*packet2.0; |
||||
let _g = lock.lock().unwrap(); |
||||
cvar.notify_one(); |
||||
// Parent should fail when it wakes up.
|
||||
panic!(); |
||||
}); |
||||
|
||||
let &(ref lock, ref cvar) = &*packet.0; |
||||
let mut lock = lock.lock().unwrap(); |
||||
tx.send(()).unwrap(); |
||||
while *lock == 1 { |
||||
match cvar.wait(lock) { |
||||
Ok(l) => { |
||||
lock = l; |
||||
assert_eq!(*lock, 1); |
||||
} |
||||
Err(..) => break, |
||||
} |
||||
} |
||||
} |
||||
|
||||
#[test] |
||||
fn test_mutex_arc_poison() { |
||||
let arc = Arc::new(Mutex::new(1)); |
||||
assert!(!arc.is_poisoned()); |
||||
let arc2 = arc.clone(); |
||||
let _ = thread::spawn(move|| { |
||||
let lock = arc2.lock().unwrap(); |
||||
assert_eq!(*lock, 2); |
||||
}).join(); |
||||
assert!(arc.lock().is_err()); |
||||
assert!(arc.is_poisoned()); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_mutex_arc_nested() { |
||||
// Tests nested mutexes and access
|
||||
// to underlying data.
|
||||
let arc = Arc::new(Mutex::new(1)); |
||||
let arc2 = Arc::new(Mutex::new(arc)); |
||||
let (tx, rx) = channel(); |
||||
let _t = thread::spawn(move|| { |
||||
let lock = arc2.lock().unwrap(); |
||||
let lock2 = lock.lock().unwrap(); |
||||
assert_eq!(*lock2, 1); |
||||
tx.send(()).unwrap(); |
||||
}); |
||||
rx.recv().unwrap(); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_mutex_arc_access_in_unwind() { |
||||
let arc = Arc::new(Mutex::new(1)); |
||||
let arc2 = arc.clone(); |
||||
let _ = thread::spawn(move|| -> () { |
||||
struct Unwinder { |
||||
i: Arc<Mutex<i32>>, |
||||
} |
||||
impl Drop for Unwinder { |
||||
fn drop(&mut self) { |
||||
*self.i.lock().unwrap() += 1; |
||||
} |
||||
} |
||||
let _u = Unwinder { i: arc2 }; |
||||
panic!(); |
||||
}).join(); |
||||
let lock = arc.lock().unwrap(); |
||||
assert_eq!(*lock, 2); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_mutex_unsized() { |
||||
let mutex: &Mutex<[i32]> = &Mutex::new([1, 2, 3]); |
||||
{ |
||||
let b = &mut *mutex.lock().unwrap(); |
||||
b[0] = 4; |
||||
b[2] = 5; |
||||
} |
||||
let comp: &[i32] = &[4, 2, 5]; |
||||
assert_eq!(&*mutex.lock().unwrap(), comp); |
||||
} |
||||
} |
||||
@ -0,0 +1,84 @@
@@ -0,0 +1,84 @@
|
||||
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
||||
// file at the top-level directory of this distribution and at
|
||||
// http://rust-lang.org/COPYRIGHT.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use cell::UnsafeCell; |
||||
use mem; |
||||
|
||||
use libctru::synchronization; |
||||
|
||||
pub struct Mutex { inner: UnsafeCell<synchronization::LightLock> } |
||||
|
||||
#[inline] |
||||
pub unsafe fn raw(m: &Mutex) -> *mut synchronization::LightLock { |
||||
m.inner.get() |
||||
} |
||||
|
||||
unsafe impl Send for Mutex {} |
||||
unsafe impl Sync for Mutex {} |
||||
|
||||
#[allow(dead_code)] // sys isn't exported yet
|
||||
impl Mutex { |
||||
pub const fn new() -> Mutex { |
||||
Mutex { inner: UnsafeCell::new(0) } |
||||
} |
||||
#[inline] |
||||
pub unsafe fn init(&mut self) { |
||||
synchronization::LightLock_Init(self.inner.get()); |
||||
} |
||||
#[inline] |
||||
pub unsafe fn lock(&self) { |
||||
synchronization::LightLock_Lock(self.inner.get()); |
||||
} |
||||
#[inline] |
||||
pub unsafe fn unlock(&self) { |
||||
synchronization::LightLock_Unlock(self.inner.get()); |
||||
} |
||||
#[inline] |
||||
pub unsafe fn try_lock(&self) -> bool { |
||||
match synchronization::LightLock_TryLock(self.inner.get()) { |
||||
0 => true, |
||||
_ => false, |
||||
} |
||||
} |
||||
#[inline] |
||||
pub unsafe fn destroy(&self) {} |
||||
} |
||||
|
||||
pub struct ReentrantMutex { inner: UnsafeCell<synchronization::RecursiveLock> } |
||||
|
||||
unsafe impl Send for ReentrantMutex {} |
||||
unsafe impl Sync for ReentrantMutex {} |
||||
|
||||
impl ReentrantMutex { |
||||
pub unsafe fn uninitialized() -> ReentrantMutex { |
||||
ReentrantMutex { inner: mem::uninitialized() } |
||||
} |
||||
#[inline] |
||||
pub unsafe fn init(&mut self) { |
||||
synchronization::RecursiveLock_Init(self.inner.get()); |
||||
} |
||||
#[inline] |
||||
pub unsafe fn lock(&self) { |
||||
synchronization::RecursiveLock_Lock(self.inner.get()); |
||||
} |
||||
#[inline] |
||||
pub unsafe fn unlock(&self) { |
||||
synchronization::RecursiveLock_Unlock(self.inner.get()); |
||||
} |
||||
#[inline] |
||||
pub unsafe fn try_lock(&self) -> bool { |
||||
match synchronization::RecursiveLock_TryLock(self.inner.get()) { |
||||
0 => true, |
||||
_ => false, |
||||
} |
||||
} |
||||
#[inline] |
||||
pub unsafe fn destroy(&self) {} |
||||
} |
||||
@ -0,0 +1,66 @@
@@ -0,0 +1,66 @@
|
||||
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
||||
// file at the top-level directory of this distribution and at
|
||||
// http://rust-lang.org/COPYRIGHT.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use sys::mutex as imp; |
||||
|
||||
/// An OS-based mutual exclusion lock.
|
||||
///
|
||||
/// This is the thinnest cross-platform wrapper around OS mutexes. All usage of
|
||||
/// this mutex is unsafe and it is recommended to instead use the safe wrapper
|
||||
/// at the top level of the crate instead of this type.
|
||||
pub struct Mutex(imp::Mutex); |
||||
|
||||
unsafe impl Sync for Mutex {} |
||||
|
||||
impl Mutex { |
||||
/// Creates a new mutex for use.
|
||||
///
|
||||
/// Behavior is undefined if the mutex is moved after it is
|
||||
/// first used with any of the functions below.
|
||||
pub const fn new() -> Mutex { Mutex(imp::Mutex::new()) } |
||||
|
||||
/// Prepare the mutex for use.
|
||||
///
|
||||
/// This should be called once the mutex is at a stable memory address.
|
||||
#[inline] |
||||
pub unsafe fn init(&mut self) { self.0.init() } |
||||
|
||||
/// Locks the mutex blocking the current thread until it is available.
|
||||
///
|
||||
/// Behavior is undefined if the mutex has been moved between this and any
|
||||
/// previous function call.
|
||||
#[inline] |
||||
pub unsafe fn lock(&self) { self.0.lock() } |
||||
|
||||
/// Attempts to lock the mutex without blocking, returning whether it was
|
||||
/// successfully acquired or not.
|
||||
///
|
||||
/// Behavior is undefined if the mutex has been moved between this and any
|
||||
/// previous function call.
|
||||
#[inline] |
||||
pub unsafe fn try_lock(&self) -> bool { self.0.try_lock() } |
||||
|
||||
/// Unlocks the mutex.
|
||||
///
|
||||
/// Behavior is undefined if the current thread does not actually hold the
|
||||
/// mutex.
|
||||
#[inline] |
||||
pub unsafe fn unlock(&self) { self.0.unlock() } |
||||
|
||||
/// Deallocates all resources associated with this mutex.
|
||||
///
|
||||
/// Behavior is undefined if there are current or will be future users of
|
||||
/// this mutex.
|
||||
#[inline] |
||||
pub unsafe fn destroy(&self) { self.0.destroy() } |
||||
} |
||||
|
||||
// not meant to be exported to the outside world, just the containing module
|
||||
pub fn raw(mutex: &Mutex) -> &imp::Mutex { &mutex.0 } |
||||
@ -0,0 +1,199 @@
@@ -0,0 +1,199 @@
|
||||
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
||||
// file at the top-level directory of this distribution and at
|
||||
// http://rust-lang.org/COPYRIGHT.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use error::{Error}; |
||||
use fmt; |
||||
use sync::atomic::{AtomicBool, Ordering}; |
||||
use thread; |
||||
|
||||
pub struct Flag { failed: AtomicBool } |
||||
|
||||
// Note that the Ordering uses to access the `failed` field of `Flag` below is
|
||||
// always `Relaxed`, and that's because this isn't actually protecting any data,
|
||||
// it's just a flag whether we've panicked or not.
|
||||
//
|
||||
// The actual location that this matters is when a mutex is **locked** which is
|
||||
// where we have external synchronization ensuring that we see memory
|
||||
// reads/writes to this flag.
|
||||
//
|
||||
// As a result, if it matters, we should see the correct value for `failed` in
|
||||
// all cases.
|
||||
|
||||
impl Flag { |
||||
pub const fn new() -> Flag { |
||||
Flag { failed: AtomicBool::new(false) } |
||||
} |
||||
|
||||
#[inline] |
||||
pub fn borrow(&self) -> LockResult<Guard> { |
||||
let ret = Guard { panicking: thread::panicking() }; |
||||
if self.get() { |
||||
Err(PoisonError::new(ret)) |
||||
} else { |
||||
Ok(ret) |
||||
} |
||||
} |
||||
|
||||
#[inline] |
||||
pub fn done(&self, guard: &Guard) { |
||||
if !guard.panicking && thread::panicking() { |
||||
self.failed.store(true, Ordering::Relaxed); |
||||
} |
||||
} |
||||
|
||||
#[inline] |
||||
pub fn get(&self) -> bool { |
||||
self.failed.load(Ordering::Relaxed) |
||||
} |
||||
} |
||||
|
||||
pub struct Guard { |
||||
panicking: bool, |
||||
} |
||||
|
||||
/// A type of error which can be returned whenever a lock is acquired.
|
||||
///
|
||||
/// Both Mutexes and RwLocks are poisoned whenever a thread fails while the lock
|
||||
/// is held. The precise semantics for when a lock is poisoned is documented on
|
||||
/// each lock, but once a lock is poisoned then all future acquisitions will
|
||||
/// return this error.
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
pub struct PoisonError<T> { |
||||
guard: T, |
||||
} |
||||
|
||||
/// An enumeration of possible errors which can occur while calling the
|
||||
/// `try_lock` method.
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
pub enum TryLockError<T> { |
||||
/// The lock could not be acquired because another thread failed while holding
|
||||
/// the lock.
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
Poisoned(#[stable(feature = "rust1", since = "1.0.0")] PoisonError<T>), |
||||
/// The lock could not be acquired at this time because the operation would
|
||||
/// otherwise block.
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
WouldBlock, |
||||
} |
||||
|
||||
/// A type alias for the result of a lock method which can be poisoned.
|
||||
///
|
||||
/// The `Ok` variant of this result indicates that the primitive was not
|
||||
/// poisoned, and the `Guard` is contained within. The `Err` variant indicates
|
||||
/// that the primitive was poisoned. Note that the `Err` variant *also* carries
|
||||
/// the associated guard, and it can be acquired through the `into_inner`
|
||||
/// method.
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
pub type LockResult<Guard> = Result<Guard, PoisonError<Guard>>; |
||||
|
||||
/// A type alias for the result of a nonblocking locking method.
|
||||
///
|
||||
/// For more information, see `LockResult`. A `TryLockResult` doesn't
|
||||
/// necessarily hold the associated guard in the `Err` type as the lock may not
|
||||
/// have been acquired for other reasons.
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
pub type TryLockResult<Guard> = Result<Guard, TryLockError<Guard>>; |
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
impl<T> fmt::Debug for PoisonError<T> { |
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
||||
"PoisonError { inner: .. }".fmt(f) |
||||
} |
||||
} |
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
impl<T> fmt::Display for PoisonError<T> { |
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
||||
"poisoned lock: another task failed inside".fmt(f) |
||||
} |
||||
} |
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
impl<T> Error for PoisonError<T> { |
||||
fn description(&self) -> &str { |
||||
"poisoned lock: another task failed inside" |
||||
} |
||||
} |
||||
|
||||
impl<T> PoisonError<T> { |
||||
/// Creates a `PoisonError`.
|
||||
#[stable(feature = "sync_poison", since = "1.2.0")] |
||||
pub fn new(guard: T) -> PoisonError<T> { |
||||
PoisonError { guard: guard } |
||||
} |
||||
|
||||
/// Consumes this error indicating that a lock is poisoned, returning the
|
||||
/// underlying guard to allow access regardless.
|
||||
#[stable(feature = "sync_poison", since = "1.2.0")] |
||||
pub fn into_inner(self) -> T { self.guard } |
||||
|
||||
/// Reaches into this error indicating that a lock is poisoned, returning a
|
||||
/// reference to the underlying guard to allow access regardless.
|
||||
#[stable(feature = "sync_poison", since = "1.2.0")] |
||||
pub fn get_ref(&self) -> &T { &self.guard } |
||||
|
||||
/// Reaches into this error indicating that a lock is poisoned, returning a
|
||||
/// mutable reference to the underlying guard to allow access regardless.
|
||||
#[stable(feature = "sync_poison", since = "1.2.0")] |
||||
pub fn get_mut(&mut self) -> &mut T { &mut self.guard } |
||||
} |
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
impl<T> From<PoisonError<T>> for TryLockError<T> { |
||||
fn from(err: PoisonError<T>) -> TryLockError<T> { |
||||
TryLockError::Poisoned(err) |
||||
} |
||||
} |
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
impl<T> fmt::Debug for TryLockError<T> { |
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
||||
match *self { |
||||
TryLockError::Poisoned(..) => "Poisoned(..)".fmt(f), |
||||
TryLockError::WouldBlock => "WouldBlock".fmt(f) |
||||
} |
||||
} |
||||
} |
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
impl<T> fmt::Display for TryLockError<T> { |
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
||||
match *self { |
||||
TryLockError::Poisoned(..) => "poisoned lock: another task failed inside", |
||||
TryLockError::WouldBlock => "try_lock failed because the operation would block" |
||||
}.fmt(f) |
||||
} |
||||
} |
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")] |
||||
impl<T> Error for TryLockError<T> { |
||||
fn description(&self) -> &str { |
||||
match *self { |
||||
TryLockError::Poisoned(ref p) => p.description(), |
||||
TryLockError::WouldBlock => "try_lock failed because the operation would block" |
||||
} |
||||
} |
||||
|
||||
fn cause(&self) -> Option<&Error> { |
||||
match *self { |
||||
TryLockError::Poisoned(ref p) => Some(p), |
||||
_ => None |
||||
} |
||||
} |
||||
} |
||||
|
||||
pub fn map_result<T, U, F>(result: LockResult<T>, f: F) |
||||
-> LockResult<U> |
||||
where F: FnOnce(T) -> U { |
||||
match result { |
||||
Ok(t) => Ok(f(t)), |
||||
Err(PoisonError { guard }) => Err(PoisonError::new(f(guard))) |
||||
} |
||||
} |
||||
@ -0,0 +1,236 @@
@@ -0,0 +1,236 @@
|
||||
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
|
||||
// file at the top-level directory of this distribution and at
|
||||
// http://rust-lang.org/COPYRIGHT.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use fmt; |
||||
use marker; |
||||
use ops::Deref; |
||||
use sys_common::poison::{self, TryLockError, TryLockResult, LockResult}; |
||||
use sys::mutex as sys; |
||||
|
||||
/// A re-entrant mutual exclusion
|
||||
///
|
||||
/// This mutex will block *other* threads waiting for the lock to become
|
||||
/// available. The thread which has already locked the mutex can lock it
|
||||
/// multiple times without blocking, preventing a common source of deadlocks.
|
||||
pub struct ReentrantMutex<T> { |
||||
inner: Box<sys::ReentrantMutex>, |
||||
poison: poison::Flag, |
||||
data: T, |
||||
} |
||||
|
||||
unsafe impl<T: Send> Send for ReentrantMutex<T> {} |
||||
unsafe impl<T: Send> Sync for ReentrantMutex<T> {} |
||||
|
||||
|
||||
/// An RAII implementation of a "scoped lock" of a mutex. When this structure is
|
||||
/// dropped (falls out of scope), the lock will be unlocked.
|
||||
///
|
||||
/// The data protected by the mutex can be accessed through this guard via its
|
||||
/// Deref implementation.
|
||||
///
|
||||
/// # Mutability
|
||||
///
|
||||
/// Unlike `MutexGuard`, `ReentrantMutexGuard` does not implement `DerefMut`,
|
||||
/// because implementation of the trait would violate Rust’s reference aliasing
|
||||
/// rules. Use interior mutability (usually `RefCell`) in order to mutate the
|
||||
/// guarded data.
|
||||
#[must_use] |
||||
pub struct ReentrantMutexGuard<'a, T: 'a> { |
||||
// funny underscores due to how Deref currently works (it disregards field
|
||||
// privacy).
|
||||
__lock: &'a ReentrantMutex<T>, |
||||
__poison: poison::Guard, |
||||
} |
||||
|
||||
impl<'a, T> !marker::Send for ReentrantMutexGuard<'a, T> {} |
||||
|
||||
|
||||
impl<T> ReentrantMutex<T> { |
||||
/// Creates a new reentrant mutex in an unlocked state.
|
||||
pub fn new(t: T) -> ReentrantMutex<T> { |
||||
unsafe { |
||||
let mut mutex = ReentrantMutex { |
||||
inner: box sys::ReentrantMutex::uninitialized(), |
||||
poison: poison::Flag::new(), |
||||
data: t, |
||||
}; |
||||
mutex.inner.init(); |
||||
mutex |
||||
} |
||||
} |
||||
|
||||
/// Acquires a mutex, blocking the current thread until it is able to do so.
|
||||
///
|
||||
/// This function will block the caller until it is available to acquire the mutex.
|
||||
/// Upon returning, the thread is the only thread with the mutex held. When the thread
|
||||
/// calling this method already holds the lock, the call shall succeed without
|
||||
/// blocking.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// If another user of this mutex panicked while holding the mutex, then
|
||||
/// this call will return failure if the mutex would otherwise be
|
||||
/// acquired.
|
||||
pub fn lock(&self) -> LockResult<ReentrantMutexGuard<T>> { |
||||
unsafe { self.inner.lock() } |
||||
ReentrantMutexGuard::new(&self) |
||||
} |
||||
|
||||
/// 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.
|
||||
///
|
||||
/// This function does not block.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// If another user of this mutex panicked while holding the mutex, then
|
||||
/// this call will return failure if the mutex would otherwise be
|
||||
/// acquired.
|
||||
pub fn try_lock(&self) -> TryLockResult<ReentrantMutexGuard<T>> { |
||||
if unsafe { self.inner.try_lock() } { |
||||
Ok(ReentrantMutexGuard::new(&self)?) |
||||
} else { |
||||
Err(TryLockError::WouldBlock) |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl<T> Drop for ReentrantMutex<T> { |
||||
fn drop(&mut self) { |
||||
// This is actually safe b/c we know that there is no further usage of
|
||||
// this mutex (it's up to the user to arrange for a mutex to get
|
||||
// dropped, that's not our job)
|
||||
unsafe { self.inner.destroy() } |
||||
} |
||||
} |
||||
|
||||
impl<T: fmt::Debug + 'static> fmt::Debug for ReentrantMutex<T> { |
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
||||
match self.try_lock() { |
||||
Ok(guard) => write!(f, "ReentrantMutex {{ data: {:?} }}", &*guard), |
||||
Err(TryLockError::Poisoned(err)) => { |
||||
write!(f, "ReentrantMutex {{ data: Poisoned({:?}) }}", &**err.get_ref()) |
||||
}, |
||||
Err(TryLockError::WouldBlock) => write!(f, "ReentrantMutex {{ <locked> }}") |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl<'mutex, T> ReentrantMutexGuard<'mutex, T> { |
||||
fn new(lock: &'mutex ReentrantMutex<T>) |
||||
-> LockResult<ReentrantMutexGuard<'mutex, T>> { |
||||
poison::map_result(lock.poison.borrow(), |guard| { |
||||
ReentrantMutexGuard { |
||||
__lock: lock, |
||||
__poison: guard, |
||||
} |
||||
}) |
||||
} |
||||
} |
||||
|
||||
impl<'mutex, T> Deref for ReentrantMutexGuard<'mutex, T> { |
||||
type Target = T; |
||||
|
||||
fn deref(&self) -> &T { |
||||
&self.__lock.data |
||||
} |
||||
} |
||||
|
||||
impl<'a, T> Drop for ReentrantMutexGuard<'a, T> { |
||||
#[inline] |
||||
fn drop(&mut self) { |
||||
unsafe { |
||||
self.__lock.poison.done(&self.__poison); |
||||
self.__lock.inner.unlock(); |
||||
} |
||||
} |
||||
} |
||||
|
||||
|
||||
#[cfg(all(test, not(target_os = "emscripten")))] |
||||
mod tests { |
||||
use sys_common::remutex::{ReentrantMutex, ReentrantMutexGuard}; |
||||
use cell::RefCell; |
||||
use sync::Arc; |
||||
use thread; |
||||
|
||||
#[test] |
||||
fn smoke() { |
||||
let m = ReentrantMutex::new(()); |
||||
{ |
||||
let a = m.lock().unwrap(); |
||||
{ |
||||
let b = m.lock().unwrap(); |
||||
{ |
||||
let c = m.lock().unwrap(); |
||||
assert_eq!(*c, ()); |
||||
} |
||||
assert_eq!(*b, ()); |
||||
} |
||||
assert_eq!(*a, ()); |
||||
} |
||||
} |
||||
|
||||
#[test] |
||||
fn is_mutex() { |
||||
let m = Arc::new(ReentrantMutex::new(RefCell::new(0))); |
||||
let m2 = m.clone(); |
||||
let lock = m.lock().unwrap(); |
||||
let child = thread::spawn(move || { |
||||
let lock = m2.lock().unwrap(); |
||||
assert_eq!(*lock.borrow(), 4950); |
||||
}); |
||||
for i in 0..100 { |
||||
let lock = m.lock().unwrap(); |
||||
*lock.borrow_mut() += i; |
||||
} |
||||
drop(lock); |
||||
child.join().unwrap(); |
||||
} |
||||
|
||||
#[test] |
||||
fn trylock_works() { |
||||
let m = Arc::new(ReentrantMutex::new(())); |
||||
let m2 = m.clone(); |
||||
let _lock = m.try_lock().unwrap(); |
||||
let _lock2 = m.try_lock().unwrap(); |
||||
thread::spawn(move || { |
||||
let lock = m2.try_lock(); |
||||
assert!(lock.is_err()); |
||||
}).join().unwrap(); |
||||
let _lock3 = m.try_lock().unwrap(); |
||||
} |
||||
|
||||
pub struct Answer<'a>(pub ReentrantMutexGuard<'a, RefCell<u32>>); |
||||
impl<'a> Drop for Answer<'a> { |
||||
fn drop(&mut self) { |
||||
*self.0.borrow_mut() = 42; |
||||
} |
||||
} |
||||
|
||||
#[test] |
||||
fn poison_works() { |
||||
let m = Arc::new(ReentrantMutex::new(RefCell::new(0))); |
||||
let mc = m.clone(); |
||||
let result = thread::spawn(move ||{ |
||||
let lock = mc.lock().unwrap(); |
||||
*lock.borrow_mut() = 1; |
||||
let lock2 = mc.lock().unwrap(); |
||||
*lock.borrow_mut() = 2; |
||||
let _answer = Answer(lock2); |
||||
panic!("What the answer to my lifetimes dilemma is?"); |
||||
}).join(); |
||||
assert!(result.is_err()); |
||||
let r = m.lock().err().unwrap().into_inner(); |
||||
assert_eq!(*r.borrow(), 42); |
||||
} |
||||
} |
||||
Loading…
Reference in new issue