summaryrefslogtreecommitdiff
path: root/src/libstd/sync/mutex.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/libstd/sync/mutex.rs')
-rw-r--r--src/libstd/sync/mutex.rs767
1 files changed, 0 insertions, 767 deletions
diff --git a/src/libstd/sync/mutex.rs b/src/libstd/sync/mutex.rs
deleted file mode 100644
index 8478457eabf..00000000000
--- a/src/libstd/sync/mutex.rs
+++ /dev/null
@@ -1,767 +0,0 @@
-use crate::cell::UnsafeCell;
-use crate::fmt;
-use crate::mem;
-use crate::ops::{Deref, DerefMut};
-use crate::ptr;
-use crate::sys_common::mutex as sys;
-use crate::sys_common::poison::{self, LockResult, TryLockError, TryLockResult};
-
-/// 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
-/// 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.
-///
-/// [`new`]: #method.new
-/// [`lock`]: #method.lock
-/// [`try_lock`]: #method.try_lock
-/// [`Result`]: ../../std/result/enum.Result.html
-/// [`unwrap()`]: ../../std/result/enum.Result.html#method.unwrap
-/// [`PoisonError`]: ../../std/sync/struct.PoisonError.html
-/// [`into_inner`]: ../../std/sync/struct.PoisonError.html#method.into_inner
-///
-/// # 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..N {
-/// let (data, tx) = (Arc::clone(&data), 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;
-/// ```
-///
-/// It is sometimes necessary to manually drop the mutex guard to unlock it
-/// sooner than the end of the enclosing scope.
-///
-/// ```
-/// use std::sync::{Arc, Mutex};
-/// use std::thread;
-///
-/// const N: usize = 3;
-///
-/// let data_mutex = Arc::new(Mutex::new(vec![1, 2, 3, 4]));
-/// let res_mutex = Arc::new(Mutex::new(0));
-///
-/// let mut threads = Vec::with_capacity(N);
-/// (0..N).for_each(|_| {
-/// let data_mutex_clone = Arc::clone(&data_mutex);
-/// let res_mutex_clone = Arc::clone(&res_mutex);
-///
-/// threads.push(thread::spawn(move || {
-/// let mut data = data_mutex_clone.lock().unwrap();
-/// // This is the result of some important and long-ish work.
-/// let result = data.iter().fold(0, |acc, x| acc + x * 2);
-/// data.push(result);
-/// drop(data);
-/// *res_mutex_clone.lock().unwrap() += result;
-/// }));
-/// });
-///
-/// let mut data = data_mutex.lock().unwrap();
-/// // This is the result of some important and long-ish work.
-/// let result = data.iter().fold(0, |acc, x| acc + x * 2);
-/// data.push(result);
-/// // We drop the `data` explicitly because it's not necessary anymore and the
-/// // thread still has work to do. This allow other threads to start working on
-/// // the data immediately, without waiting for the rest of the unrelated work
-/// // to be done here.
-/// //
-/// // It's even more important here than in the threads because we `.join` the
-/// // threads after that. If we had not dropped the mutex guard, a thread could
-/// // be waiting forever for it, causing a deadlock.
-/// drop(data);
-/// // Here the mutex guard is not assigned to a variable and so, even if the
-/// // scope does not end after this line, the mutex is still released: there is
-/// // no deadlock.
-/// *res_mutex.lock().unwrap() += result;
-///
-/// threads.into_iter().for_each(|thread| {
-/// thread
-/// .join()
-/// .expect("The thread creating or execution failed !")
-/// });
-///
-/// assert_eq!(*res_mutex.lock().unwrap(), 800);
-/// ```
-#[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(not(test), rustc_diagnostic_item = "mutex_type")]
-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 mutex 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 accessed through this guard via its
-/// [`Deref`] and [`DerefMut`] implementations.
-///
-/// This structure is created by the [`lock`] and [`try_lock`] methods on
-/// [`Mutex`].
-///
-/// [`Deref`]: ../../std/ops/trait.Deref.html
-/// [`DerefMut`]: ../../std/ops/trait.DerefMut.html
-/// [`lock`]: struct.Mutex.html#method.lock
-/// [`try_lock`]: struct.Mutex.html#method.try_lock
-/// [`Mutex`]: struct.Mutex.html
-#[must_use = "if unused the Mutex will immediately unlock"]
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct MutexGuard<'a, T: ?Sized + 'a> {
- lock: &'a Mutex<T>,
- poison: poison::Guard,
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> !Send for MutexGuard<'_, T> {}
-#[stable(feature = "mutexguard", since = "1.19.0")]
-unsafe impl<T: ?Sized + Sync> Sync for MutexGuard<'_, 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 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).
- ///
- /// # 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.raw_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.
- ///
- /// [`Err`]: ../../std/result/enum.Result.html#variant.Err
- ///
- /// # 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 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.
- ///
- /// # 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 mutex.
- //
- // 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 mutex.
- 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_from", since = "1.24.0")]
-impl<T> From<T> for Mutex<T> {
- /// Creates a new mutex in an unlocked state ready for use.
- /// This is equivalent to [`Mutex::new`].
- ///
- /// [`Mutex::new`]: ../../std/sync/struct.Mutex.html#method.new
- fn from(t: T) -> Self {
- Mutex::new(t)
- }
-}
-
-#[stable(feature = "mutex_default", since = "1.10.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) => f.debug_struct("Mutex").field("data", &&*guard).finish(),
- Err(TryLockError::Poisoned(err)) => {
- f.debug_struct("Mutex").field("data", &&**err.get_ref()).finish()
- }
- Err(TryLockError::WouldBlock) => {
- struct LockedPlaceholder;
- impl fmt::Debug for LockedPlaceholder {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- f.write_str("<locked>")
- }
- }
-
- f.debug_struct("Mutex").field("data", &LockedPlaceholder).finish()
- }
- }
- }
-}
-
-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, poison: guard })
- }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> Deref for MutexGuard<'_, T> {
- type Target = T;
-
- fn deref(&self) -> &T {
- unsafe { &*self.lock.data.get() }
- }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> DerefMut for MutexGuard<'_, T> {
- fn deref_mut(&mut self) -> &mut T {
- unsafe { &mut *self.lock.data.get() }
- }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> Drop for MutexGuard<'_, T> {
- #[inline]
- fn drop(&mut self) {
- unsafe {
- self.lock.poison.done(&self.poison);
- self.lock.inner.raw_unlock();
- }
- }
-}
-
-#[stable(feature = "std_debug", since = "1.16.0")]
-impl<T: ?Sized + fmt::Debug> fmt::Debug for MutexGuard<'_, T> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- fmt::Debug::fmt(&**self, f)
- }
-}
-
-#[stable(feature = "std_guard_impls", since = "1.20.0")]
-impl<T: ?Sized + fmt::Display> fmt::Display for MutexGuard<'_, T> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- (**self).fmt(f)
- }
-}
-
-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 crate::sync::atomic::{AtomicUsize, Ordering};
- use crate::sync::mpsc::channel;
- use crate::sync::{Arc, Condvar, Mutex};
- use crate::thread;
-
- struct Packet<T>(Arc<(Mutex<T>, Condvar)>);
-
- #[derive(Eq, PartialEq, Debug)]
- struct NonCopy(i32);
-
- #[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);
- }
-}
View Lorry Controller Status