src/libstd/sync/mutex.rs

   1 use crate::cell::UnsafeCell;
   2 use crate::fmt;
   3 use crate::mem;
   4 use crate::ops::{Deref, DerefMut};
   5 use crate::ptr;
   6 use crate::sys_common::mutex as sys;
   7 use crate::sys_common::poison::{self, LockResult, TryLockError, TryLockResult};
   8
   9 /// A mutual exclusion primitive useful for protecting shared data
  10 ///
  11 /// This mutex will block threads waiting for the lock to become available. The
  12 /// mutex can also be statically initialized or created via a [`new`]
  13 /// constructor. Each mutex has a type parameter which represents the data that
  14 /// it is protecting. The data can only be accessed through the RAII guards
  15 /// returned from [`lock`] and [`try_lock`], which guarantees that the data is only
  16 /// ever accessed when the mutex is locked.
  17 ///
  18 /// # Poisoning
  19 ///
  20 /// The mutexes in this module implement a strategy called "poisoning" where a
  21 /// mutex is considered poisoned whenever a thread panics while holding the
  22 /// mutex. Once a mutex is poisoned, all other threads are unable to access the
  23 /// data by default as it is likely tainted (some invariant is not being
  24 /// upheld).
  25 ///
  26 /// For a mutex, this means that the [`lock`] and [`try_lock`] methods return a
  27 /// [`Result`] which indicates whether a mutex has been poisoned or not. Most
  28 /// usage of a mutex will simply [`unwrap()`] these results, propagating panics
  29 /// among threads to ensure that a possibly invalid invariant is not witnessed.
  30 ///
  31 /// A poisoned mutex, however, does not prevent all access to the underlying
  32 /// data. The [`PoisonError`] type has an [`into_inner`] method which will return
  33 /// the guard that would have otherwise been returned on a successful lock. This
  34 /// allows access to the data, despite the lock being poisoned.
  35 ///
  36 /// [`new`]: #method.new
  37 /// [`lock`]: #method.lock
  38 /// [`try_lock`]: #method.try_lock
  39 /// [`Result`]: ../../std/result/enum.Result.html
  40 /// [`unwrap()`]: ../../std/result/enum.Result.html#method.unwrap
  41 /// [`PoisonError`]: ../../std/sync/struct.PoisonError.html
  42 /// [`into_inner`]: ../../std/sync/struct.PoisonError.html#method.into_inner
  43 ///
  44 /// # Examples
  45 ///
  46 /// ```
  47 /// use std::sync::{Arc, Mutex};
  48 /// use std::thread;
  49 /// use std::sync::mpsc::channel;
  50 ///
  51 /// const N: usize = 10;
  52 ///
  53 /// // Spawn a few threads to increment a shared variable (non-atomically), and
  54 /// // let the main thread know once all increments are done.
  55 /// //
  56 /// // Here we're using an Arc to share memory among threads, and the data inside
  57 /// // the Arc is protected with a mutex.
  58 /// let data = Arc::new(Mutex::new(0));
  59 ///
  60 /// let (tx, rx) = channel();
  61 /// for _ in 0..N {
  62 ///     let (data, tx) = (Arc::clone(&data), tx.clone());
  63 ///     thread::spawn(move || {
  64 ///         // The shared state can only be accessed once the lock is held.
  65 ///         // Our non-atomic increment is safe because we're the only thread
  66 ///         // which can access the shared state when the lock is held.
  67 ///         //
  68 ///         // We unwrap() the return value to assert that we are not expecting
  69 ///         // threads to ever fail while holding the lock.
  70 ///         let mut data = data.lock().unwrap();
  71 ///         *data += 1;
  72 ///         if *data == N {
  73 ///             tx.send(()).unwrap();
  74 ///         }
  75 ///         // the lock is unlocked here when `data` goes out of scope.
  76 ///     });
  77 /// }
  78 ///
  79 /// rx.recv().unwrap();
  80 /// ```
  81 ///
  82 /// To recover from a poisoned mutex:
  83 ///
  84 /// ```
  85 /// use std::sync::{Arc, Mutex};
  86 /// use std::thread;
  87 ///
  88 /// let lock = Arc::new(Mutex::new(0_u32));
  89 /// let lock2 = lock.clone();
  90 ///
  91 /// let _ = thread::spawn(move || -> () {
  92 ///     // This thread will acquire the mutex first, unwrapping the result of
  93 ///     // `lock` because the lock has not been poisoned.
  94 ///     let _guard = lock2.lock().unwrap();
  95 ///
  96 ///     // This panic while holding the lock (`_guard` is in scope) will poison
  97 ///     // the mutex.
  98 ///     panic!();
  99 /// }).join();
 100 ///
 101 /// // The lock is poisoned by this point, but the returned result can be
 102 /// // pattern matched on to return the underlying guard on both branches.
 103 /// let mut guard = match lock.lock() {
 104 ///     Ok(guard) => guard,
 105 ///     Err(poisoned) => poisoned.into_inner(),
 106 /// };
 107 ///
 108 /// *guard += 1;
 109 /// ```
 110 #[stable(feature = "rust1", since = "1.0.0")]
 111 pub struct Mutex<T: ?Sized> {
 112     // Note that this mutex is in a *box*, not inlined into the struct itself.
 113     // Once a native mutex has been used once, its address can never change (it
 114     // can't be moved). This mutex type can be safely moved at any time, so to
 115     // ensure that the native mutex is used correctly we box the inner mutex to
 116     // give it a constant address.
 117     inner: Box<sys::Mutex>,
 118     poison: poison::Flag,
 119     data: UnsafeCell<T>,
 120 }
 121
 122 // these are the only places where `T: Send` matters; all other
 123 // functionality works fine on a single thread.
 124 #[stable(feature = "rust1", since = "1.0.0")]
 125 unsafe impl<T: ?Sized + Send> Send for Mutex<T> {}
 126 #[stable(feature = "rust1", since = "1.0.0")]
 127 unsafe impl<T: ?Sized + Send> Sync for Mutex<T> {}
 128
 129 /// An RAII implementation of a "scoped lock" of a mutex. When this structure is
 130 /// dropped (falls out of scope), the lock will be unlocked.
 131 ///
 132 /// The data protected by the mutex can be accessed through this guard via its
 133 /// [`Deref`] and [`DerefMut`] implementations.
 134 ///
 135 /// This structure is created by the [`lock`] and [`try_lock`] methods on
 136 /// [`Mutex`].
 137 ///
 138 /// [`Deref`]: ../../std/ops/trait.Deref.html
 139 /// [`DerefMut`]: ../../std/ops/trait.DerefMut.html
 140 /// [`lock`]: struct.Mutex.html#method.lock
 141 /// [`try_lock`]: struct.Mutex.html#method.try_lock
 142 /// [`Mutex`]: struct.Mutex.html
 143 #[must_use = "if unused the Mutex will immediately unlock"]
 144 #[stable(feature = "rust1", since = "1.0.0")]
 145 pub struct MutexGuard<'a, T: ?Sized + 'a> {
 146     lock: &'a Mutex<T>,
 147     poison: poison::Guard,
 148 }
 149
 150 #[stable(feature = "rust1", since = "1.0.0")]
 151 impl<T: ?Sized> !Send for MutexGuard<'_, T> {}
 152 #[stable(feature = "mutexguard", since = "1.19.0")]
 153 unsafe impl<T: ?Sized + Sync> Sync for MutexGuard<'_, T> {}
 154
 155 impl<T> Mutex<T> {
 156     /// Creates a new mutex in an unlocked state ready for use.
 157     ///
 158     /// # Examples
 159     ///
 160     /// ```
 161     /// use std::sync::Mutex;
 162     ///
 163     /// let mutex = Mutex::new(0);
 164     /// ```
 165     #[stable(feature = "rust1", since = "1.0.0")]
 166     pub fn new(t: T) -> Mutex<T> {
 167         let mut m = Mutex {
 168             inner: box sys::Mutex::new(),
 169             poison: poison::Flag::new(),
 170             data: UnsafeCell::new(t),
 171         };
 172         unsafe {
 173             m.inner.init();
 174         }
 175         m
 176     }
 177 }
 178
 179 impl<T: ?Sized> Mutex<T> {
 180     /// Acquires a mutex, blocking the current thread until it is able to do so.
 181     ///
 182     /// This function will block the local thread until it is available to acquire
 183     /// the mutex. Upon returning, the thread is the only thread with the lock
 184     /// held. An RAII guard is returned to allow scoped unlock of the lock. When
 185     /// the guard goes out of scope, the mutex will be unlocked.
 186     ///
 187     /// The exact behavior on locking a mutex in the thread which already holds
 188     /// the lock is left unspecified. However, this function will not return on
 189     /// the second call (it might panic or deadlock, for example).
 190     ///
 191     /// # Errors
 192     ///
 193     /// If another user of this mutex panicked while holding the mutex, then
 194     /// this call will return an error once the mutex is acquired.
 195     ///
 196     /// # Panics
 197     ///
 198     /// This function might panic when called if the lock is already held by
 199     /// the current thread.
 200     ///
 201     /// # Examples
 202     ///
 203     /// ```
 204     /// use std::sync::{Arc, Mutex};
 205     /// use std::thread;
 206     ///
 207     /// let mutex = Arc::new(Mutex::new(0));
 208     /// let c_mutex = mutex.clone();
 209     ///
 210     /// thread::spawn(move || {
 211     ///     *c_mutex.lock().unwrap() = 10;
 212     /// }).join().expect("thread::spawn failed");
 213     /// assert_eq!(*mutex.lock().unwrap(), 10);
 214     /// ```
 215     #[stable(feature = "rust1", since = "1.0.0")]
 216     pub fn lock(&self) -> LockResult<MutexGuard<'_, T>> {
 217         unsafe {
 218             self.inner.raw_lock();
 219             MutexGuard::new(self)
 220         }
 221     }
 222
 223     /// Attempts to acquire this lock.
 224     ///
 225     /// If the lock could not be acquired at this time, then [`Err`] is returned.
 226     /// Otherwise, an RAII guard is returned. The lock will be unlocked when the
 227     /// guard is dropped.
 228     ///
 229     /// This function does not block.
 230     ///
 231     /// # Errors
 232     ///
 233     /// If another user of this mutex panicked while holding the mutex, then
 234     /// this call will return failure if the mutex would otherwise be
 235     /// acquired.
 236     ///
 237     /// [`Err`]: ../../std/result/enum.Result.html#variant.Err
 238     ///
 239     /// # Examples
 240     ///
 241     /// ```
 242     /// use std::sync::{Arc, Mutex};
 243     /// use std::thread;
 244     ///
 245     /// let mutex = Arc::new(Mutex::new(0));
 246     /// let c_mutex = mutex.clone();
 247     ///
 248     /// thread::spawn(move || {
 249     ///     let mut lock = c_mutex.try_lock();
 250     ///     if let Ok(ref mut mutex) = lock {
 251     ///         **mutex = 10;
 252     ///     } else {
 253     ///         println!("try_lock failed");
 254     ///     }
 255     /// }).join().expect("thread::spawn failed");
 256     /// assert_eq!(*mutex.lock().unwrap(), 10);
 257     /// ```
 258     #[stable(feature = "rust1", since = "1.0.0")]
 259     pub fn try_lock(&self) -> TryLockResult<MutexGuard<'_, T>> {
 260         unsafe {
 261             if self.inner.try_lock() {
 262                 Ok(MutexGuard::new(self)?)
 263             } else {
 264                 Err(TryLockError::WouldBlock)
 265             }
 266         }
 267     }
 268
 269     /// Determines whether the mutex is poisoned.
 270     ///
 271     /// If another thread is active, the mutex can still become poisoned at any
 272     /// time. You should not trust a `false` value for program correctness
 273     /// without additional synchronization.
 274     ///
 275     /// # Examples
 276     ///
 277     /// ```
 278     /// use std::sync::{Arc, Mutex};
 279     /// use std::thread;
 280     ///
 281     /// let mutex = Arc::new(Mutex::new(0));
 282     /// let c_mutex = mutex.clone();
 283     ///
 284     /// let _ = thread::spawn(move || {
 285     ///     let _lock = c_mutex.lock().unwrap();
 286     ///     panic!(); // the mutex gets poisoned
 287     /// }).join();
 288     /// assert_eq!(mutex.is_poisoned(), true);
 289     /// ```
 290     #[inline]
 291     #[stable(feature = "sync_poison", since = "1.2.0")]
 292     pub fn is_poisoned(&self) -> bool {
 293         self.poison.get()
 294     }
 295
 296     /// Consumes this mutex, returning the underlying data.
 297     ///
 298     /// # Errors
 299     ///
 300     /// If another user of this mutex panicked while holding the mutex, then
 301     /// this call will return an error instead.
 302     ///
 303     /// # Examples
 304     ///
 305     /// ```
 306     /// use std::sync::Mutex;
 307     ///
 308     /// let mutex = Mutex::new(0);
 309     /// assert_eq!(mutex.into_inner().unwrap(), 0);
 310     /// ```
 311     #[stable(feature = "mutex_into_inner", since = "1.6.0")]
 312     pub fn into_inner(self) -> LockResult<T>
 313     where
 314         T: Sized,
 315     {
 316         // We know statically that there are no outstanding references to
 317         // `self` so there's no need to lock the inner mutex.
 318         //
 319         // To get the inner value, we'd like to call `data.into_inner()`,
 320         // but because `Mutex` impl-s `Drop`, we can't move out of it, so
 321         // we'll have to destructure it manually instead.
 322         unsafe {
 323             // Like `let Mutex { inner, poison, data } = self`.
 324             let (inner, poison, data) = {
 325                 let Mutex { ref inner, ref poison, ref data } = self;
 326                 (ptr::read(inner), ptr::read(poison), ptr::read(data))
 327             };
 328             mem::forget(self);
 329             inner.destroy(); // Keep in sync with the `Drop` impl.
 330             drop(inner);
 331
 332             poison::map_result(poison.borrow(), |_| data.into_inner())
 333         }
 334     }
 335
 336     /// Returns a mutable reference to the underlying data.
 337     ///
 338     /// Since this call borrows the `Mutex` mutably, no actual locking needs to
 339     /// take place -- the mutable borrow statically guarantees no locks exist.
 340     ///
 341     /// # Errors
 342     ///
 343     /// If another user of this mutex panicked while holding the mutex, then
 344     /// this call will return an error instead.
 345     ///
 346     /// # Examples
 347     ///
 348     /// ```
 349     /// use std::sync::Mutex;
 350     ///
 351     /// let mut mutex = Mutex::new(0);
 352     /// *mutex.get_mut().unwrap() = 10;
 353     /// assert_eq!(*mutex.lock().unwrap(), 10);
 354     /// ```
 355     #[stable(feature = "mutex_get_mut", since = "1.6.0")]
 356     pub fn get_mut(&mut self) -> LockResult<&mut T> {
 357         // We know statically that there are no other references to `self`, so
 358         // there's no need to lock the inner mutex.
 359         let data = unsafe { &mut *self.data.get() };
 360         poison::map_result(self.poison.borrow(), |_| data)
 361     }
 362 }
 363
 364 #[stable(feature = "rust1", since = "1.0.0")]
 365 unsafe impl<#[may_dangle] T: ?Sized> Drop for Mutex<T> {
 366     fn drop(&mut self) {
 367         // This is actually safe b/c we know that there is no further usage of
 368         // this mutex (it's up to the user to arrange for a mutex to get
 369         // dropped, that's not our job)
 370         //
 371         // IMPORTANT: This code must be kept in sync with `Mutex::into_inner`.
 372         unsafe { self.inner.destroy() }
 373     }
 374 }
 375
 376 #[stable(feature = "mutex_from", since = "1.24.0")]
 377 impl<T> From<T> for Mutex<T> {
 378     /// Creates a new mutex in an unlocked state ready for use.
 379     /// This is equivalent to [`Mutex::new`].
 380     ///
 381     /// [`Mutex::new`]: ../../std/sync/struct.Mutex.html#method.new
 382     fn from(t: T) -> Self {
 383         Mutex::new(t)
 384     }
 385 }
 386
 387 #[stable(feature = "mutex_default", since = "1.10.0")]
 388 impl<T: ?Sized + Default> Default for Mutex<T> {
 389     /// Creates a `Mutex<T>`, with the `Default` value for T.
 390     fn default() -> Mutex<T> {
 391         Mutex::new(Default::default())
 392     }
 393 }
 394
 395 #[stable(feature = "rust1", since = "1.0.0")]
 396 impl<T: ?Sized + fmt::Debug> fmt::Debug for Mutex<T> {
 397     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 398         match self.try_lock() {
 399             Ok(guard) => f.debug_struct("Mutex").field("data", &&*guard).finish(),
 400             Err(TryLockError::Poisoned(err)) => {
 401                 f.debug_struct("Mutex").field("data", &&**err.get_ref()).finish()
 402             }
 403             Err(TryLockError::WouldBlock) => {
 404                 struct LockedPlaceholder;
 405                 impl fmt::Debug for LockedPlaceholder {
 406                     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 407                         f.write_str("<locked>")
 408                     }
 409                 }
 410
 411                 f.debug_struct("Mutex").field("data", &LockedPlaceholder).finish()
 412             }
 413         }
 414     }
 415 }
 416
 417 impl<'mutex, T: ?Sized> MutexGuard<'mutex, T> {
 418     unsafe fn new(lock: &'mutex Mutex<T>) -> LockResult<MutexGuard<'mutex, T>> {
 419         poison::map_result(lock.poison.borrow(), |guard| MutexGuard { lock: lock, poison: guard })
 420     }
 421 }
 422
 423 #[stable(feature = "rust1", since = "1.0.0")]
 424 impl<T: ?Sized> Deref for MutexGuard<'_, T> {
 425     type Target = T;
 426
 427     fn deref(&self) -> &T {
 428         unsafe { &*self.lock.data.get() }
 429     }
 430 }
 431
 432 #[stable(feature = "rust1", since = "1.0.0")]
 433 impl<T: ?Sized> DerefMut for MutexGuard<'_, T> {
 434     fn deref_mut(&mut self) -> &mut T {
 435         unsafe { &mut *self.lock.data.get() }
 436     }
 437 }
 438
 439 #[stable(feature = "rust1", since = "1.0.0")]
 440 impl<T: ?Sized> Drop for MutexGuard<'_, T> {
 441     #[inline]
 442     fn drop(&mut self) {
 443         unsafe {
 444             self.lock.poison.done(&self.poison);
 445             self.lock.inner.raw_unlock();
 446         }
 447     }
 448 }
 449
 450 #[stable(feature = "std_debug", since = "1.16.0")]
 451 impl<T: ?Sized + fmt::Debug> fmt::Debug for MutexGuard<'_, T> {
 452     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 453         fmt::Debug::fmt(&**self, f)
 454     }
 455 }
 456
 457 #[stable(feature = "std_guard_impls", since = "1.20.0")]
 458 impl<T: ?Sized + fmt::Display> fmt::Display for MutexGuard<'_, T> {
 459     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 460         (**self).fmt(f)
 461     }
 462 }
 463
 464 pub fn guard_lock<'a, T: ?Sized>(guard: &MutexGuard<'a, T>) -> &'a sys::Mutex {
 465     &guard.lock.inner
 466 }
 467
 468 pub fn guard_poison<'a, T: ?Sized>(guard: &MutexGuard<'a, T>) -> &'a poison::Flag {
 469     &guard.lock.poison
 470 }
 471
 472 #[cfg(all(test, not(target_os = "emscripten")))]
 473 mod tests {
 474     use crate::sync::atomic::{AtomicUsize, Ordering};
 475     use crate::sync::mpsc::channel;
 476     use crate::sync::{Arc, Condvar, Mutex};
 477     use crate::thread;
 478
 479     struct Packet<T>(Arc<(Mutex<T>, Condvar)>);
 480
 481     #[derive(Eq, PartialEq, Debug)]
 482     struct NonCopy(i32);
 483
 484     #[test]
 485     fn smoke() {
 486         let m = Mutex::new(());
 487         drop(m.lock().unwrap());
 488         drop(m.lock().unwrap());
 489     }
 490
 491     #[test]
 492     fn lots_and_lots() {
 493         const J: u32 = 1000;
 494         const K: u32 = 3;
 495
 496         let m = Arc::new(Mutex::new(0));
 497
 498         fn inc(m: &Mutex<u32>) {
 499             for _ in 0..J {
 500                 *m.lock().unwrap() += 1;
 501             }
 502         }
 503
 504         let (tx, rx) = channel();
 505         for _ in 0..K {
 506             let tx2 = tx.clone();
 507             let m2 = m.clone();
 508             thread::spawn(move || {
 509                 inc(&m2);
 510                 tx2.send(()).unwrap();
 511             });
 512             let tx2 = tx.clone();
 513             let m2 = m.clone();
 514             thread::spawn(move || {
 515                 inc(&m2);
 516                 tx2.send(()).unwrap();
 517             });
 518         }
 519
 520         drop(tx);
 521         for _ in 0..2 * K {
 522             rx.recv().unwrap();
 523         }
 524         assert_eq!(*m.lock().unwrap(), J * K * 2);
 525     }
 526
 527     #[test]
 528     fn try_lock() {
 529         let m = Mutex::new(());
 530         *m.try_lock().unwrap() = ();
 531     }
 532
 533     #[test]
 534     fn test_into_inner() {
 535         let m = Mutex::new(NonCopy(10));
 536         assert_eq!(m.into_inner().unwrap(), NonCopy(10));
 537     }
 538
 539     #[test]
 540     fn test_into_inner_drop() {
 541         struct Foo(Arc<AtomicUsize>);
 542         impl Drop for Foo {
 543             fn drop(&mut self) {
 544                 self.0.fetch_add(1, Ordering::SeqCst);
 545             }
 546         }
 547         let num_drops = Arc::new(AtomicUsize::new(0));
 548         let m = Mutex::new(Foo(num_drops.clone()));
 549         assert_eq!(num_drops.load(Ordering::SeqCst), 0);
 550         {
 551             let _inner = m.into_inner().unwrap();
 552             assert_eq!(num_drops.load(Ordering::SeqCst), 0);
 553         }
 554         assert_eq!(num_drops.load(Ordering::SeqCst), 1);
 555     }
 556
 557     #[test]
 558     fn test_into_inner_poison() {
 559         let m = Arc::new(Mutex::new(NonCopy(10)));
 560         let m2 = m.clone();
 561         let _ = thread::spawn(move || {
 562             let _lock = m2.lock().unwrap();
 563             panic!("test panic in inner thread to poison mutex");
 564         })
 565         .join();
 566
 567         assert!(m.is_poisoned());
 568         match Arc::try_unwrap(m).unwrap().into_inner() {
 569             Err(e) => assert_eq!(e.into_inner(), NonCopy(10)),
 570             Ok(x) => panic!("into_inner of poisoned Mutex is Ok: {:?}", x),
 571         }
 572     }
 573
 574     #[test]
 575     fn test_get_mut() {
 576         let mut m = Mutex::new(NonCopy(10));
 577         *m.get_mut().unwrap() = NonCopy(20);
 578         assert_eq!(m.into_inner().unwrap(), NonCopy(20));
 579     }
 580
 581     #[test]
 582     fn test_get_mut_poison() {
 583         let m = Arc::new(Mutex::new(NonCopy(10)));
 584         let m2 = m.clone();
 585         let _ = thread::spawn(move || {
 586             let _lock = m2.lock().unwrap();
 587             panic!("test panic in inner thread to poison mutex");
 588         })
 589         .join();
 590
 591         assert!(m.is_poisoned());
 592         match Arc::try_unwrap(m).unwrap().get_mut() {
 593             Err(e) => assert_eq!(*e.into_inner(), NonCopy(10)),
 594             Ok(x) => panic!("get_mut of poisoned Mutex is Ok: {:?}", x),
 595         }
 596     }
 597
 598     #[test]
 599     fn test_mutex_arc_condvar() {
 600         let packet = Packet(Arc::new((Mutex::new(false), Condvar::new())));
 601         let packet2 = Packet(packet.0.clone());
 602         let (tx, rx) = channel();
 603         let _t = thread::spawn(move || {
 604             // wait until parent gets in
 605             rx.recv().unwrap();
 606             let &(ref lock, ref cvar) = &*packet2.0;
 607             let mut lock = lock.lock().unwrap();
 608             *lock = true;
 609             cvar.notify_one();
 610         });
 611
 612         let &(ref lock, ref cvar) = &*packet.0;
 613         let mut lock = lock.lock().unwrap();
 614         tx.send(()).unwrap();
 615         assert!(!*lock);
 616         while !*lock {
 617             lock = cvar.wait(lock).unwrap();
 618         }
 619     }
 620
 621     #[test]
 622     fn test_arc_condvar_poison() {
 623         let packet = Packet(Arc::new((Mutex::new(1), Condvar::new())));
 624         let packet2 = Packet(packet.0.clone());
 625         let (tx, rx) = channel();
 626
 627         let _t = thread::spawn(move || -> () {
 628             rx.recv().unwrap();
 629             let &(ref lock, ref cvar) = &*packet2.0;
 630             let _g = lock.lock().unwrap();
 631             cvar.notify_one();
 632             // Parent should fail when it wakes up.
 633             panic!();
 634         });
 635
 636         let &(ref lock, ref cvar) = &*packet.0;
 637         let mut lock = lock.lock().unwrap();
 638         tx.send(()).unwrap();
 639         while *lock == 1 {
 640             match cvar.wait(lock) {
 641                 Ok(l) => {
 642                     lock = l;
 643                     assert_eq!(*lock, 1);
 644                 }
 645                 Err(..) => break,
 646             }
 647         }
 648     }
 649
 650     #[test]
 651     fn test_mutex_arc_poison() {
 652         let arc = Arc::new(Mutex::new(1));
 653         assert!(!arc.is_poisoned());
 654         let arc2 = arc.clone();
 655         let _ = thread::spawn(move || {
 656             let lock = arc2.lock().unwrap();
 657             assert_eq!(*lock, 2);
 658         })
 659         .join();
 660         assert!(arc.lock().is_err());
 661         assert!(arc.is_poisoned());
 662     }
 663
 664     #[test]
 665     fn test_mutex_arc_nested() {
 666         // Tests nested mutexes and access
 667         // to underlying data.
 668         let arc = Arc::new(Mutex::new(1));
 669         let arc2 = Arc::new(Mutex::new(arc));
 670         let (tx, rx) = channel();
 671         let _t = thread::spawn(move || {
 672             let lock = arc2.lock().unwrap();
 673             let lock2 = lock.lock().unwrap();
 674             assert_eq!(*lock2, 1);
 675             tx.send(()).unwrap();
 676         });
 677         rx.recv().unwrap();
 678     }
 679
 680     #[test]
 681     fn test_mutex_arc_access_in_unwind() {
 682         let arc = Arc::new(Mutex::new(1));
 683         let arc2 = arc.clone();
 684         let _ = thread::spawn(move || -> () {
 685             struct Unwinder {
 686                 i: Arc<Mutex<i32>>,
 687             }
 688             impl Drop for Unwinder {
 689                 fn drop(&mut self) {
 690                     *self.i.lock().unwrap() += 1;
 691                 }
 692             }
 693             let _u = Unwinder { i: arc2 };
 694             panic!();
 695         })
 696         .join();
 697         let lock = arc.lock().unwrap();
 698         assert_eq!(*lock, 2);
 699     }
 700
 701     #[test]
 702     fn test_mutex_unsized() {
 703         let mutex: &Mutex<[i32]> = &Mutex::new([1, 2, 3]);
 704         {
 705             let b = &mut *mutex.lock().unwrap();
 706             b[0] = 4;
 707             b[2] = 5;
 708         }
 709         let comp: &[i32] = &[4, 2, 5];
 710         assert_eq!(&*mutex.lock().unwrap(), comp);
 711     }
 712 }