src/libstd/sync/mutex.rs

   1 use cell::UnsafeCell;
   2 use fmt;
   3 use mem;
   4 use ops::{Deref, DerefMut};
   5 use ptr;
   6 use sys_common::mutex as sys;
   7 use sys_common::poison::{self, TryLockError, TryLockResult, LockResult};
   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     // funny underscores due to how Deref/DerefMut currently work (they
 147     // disregard field privacy).
 148     __lock: &'a Mutex<T>,
 149     __poison: poison::Guard,
 150 }
 151
 152 #[stable(feature = "rust1", since = "1.0.0")]
 153 impl<'a, T: ?Sized> !Send for MutexGuard<'a, T> { }
 154 #[stable(feature = "mutexguard", since = "1.19.0")]
 155 unsafe impl<'a, T: ?Sized + Sync> Sync for MutexGuard<'a, T> { }
 156
 157 impl<T> Mutex<T> {
 158     /// Creates a new mutex in an unlocked state ready for use.
 159     ///
 160     /// # Examples
 161     ///
 162     /// ```
 163     /// use std::sync::Mutex;
 164     ///
 165     /// let mutex = Mutex::new(0);
 166     /// ```
 167     #[stable(feature = "rust1", since = "1.0.0")]
 168     pub fn new(t: T) -> Mutex<T> {
 169         let mut m = Mutex {
 170             inner: box sys::Mutex::new(),
 171             poison: poison::Flag::new(),
 172             data: UnsafeCell::new(t),
 173         };
 174         unsafe {
 175             m.inner.init();
 176         }
 177         m
 178     }
 179 }
 180
 181 impl<T: ?Sized> Mutex<T> {
 182     /// Acquires a mutex, blocking the current thread until it is able to do so.
 183     ///
 184     /// This function will block the local thread until it is available to acquire
 185     /// the mutex. Upon returning, the thread is the only thread with the lock
 186     /// held. An RAII guard is returned to allow scoped unlock of the lock. When
 187     /// the guard goes out of scope, the mutex will be unlocked.
 188     ///
 189     /// The exact behavior on locking a mutex in the thread which already holds
 190     /// the lock is left unspecified. However, this function will not return on
 191     /// the second call (it might panic or deadlock, for example).
 192     ///
 193     /// # Errors
 194     ///
 195     /// If another user of this mutex panicked while holding the mutex, then
 196     /// this call will return an error once the mutex is acquired.
 197     ///
 198     /// # Panics
 199     ///
 200     /// This function might panic when called if the lock is already held by
 201     /// the current thread.
 202     ///
 203     /// # Examples
 204     ///
 205     /// ```
 206     /// use std::sync::{Arc, Mutex};
 207     /// use std::thread;
 208     ///
 209     /// let mutex = Arc::new(Mutex::new(0));
 210     /// let c_mutex = mutex.clone();
 211     ///
 212     /// thread::spawn(move || {
 213     ///     *c_mutex.lock().unwrap() = 10;
 214     /// }).join().expect("thread::spawn failed");
 215     /// assert_eq!(*mutex.lock().unwrap(), 10);
 216     /// ```
 217     #[stable(feature = "rust1", since = "1.0.0")]
 218     pub fn lock(&self) -> LockResult<MutexGuard<T>> {
 219         unsafe {
 220             self.inner.raw_lock();
 221             MutexGuard::new(self)
 222         }
 223     }
 224
 225     /// Attempts to acquire this lock.
 226     ///
 227     /// If the lock could not be acquired at this time, then [`Err`] is returned.
 228     /// Otherwise, an RAII guard is returned. The lock will be unlocked when the
 229     /// guard is dropped.
 230     ///
 231     /// This function does not block.
 232     ///
 233     /// # Errors
 234     ///
 235     /// If another user of this mutex panicked while holding the mutex, then
 236     /// this call will return failure if the mutex would otherwise be
 237     /// acquired.
 238     ///
 239     /// [`Err`]: ../../std/result/enum.Result.html#variant.Err
 240     ///
 241     /// # Examples
 242     ///
 243     /// ```
 244     /// use std::sync::{Arc, Mutex};
 245     /// use std::thread;
 246     ///
 247     /// let mutex = Arc::new(Mutex::new(0));
 248     /// let c_mutex = mutex.clone();
 249     ///
 250     /// thread::spawn(move || {
 251     ///     let mut lock = c_mutex.try_lock();
 252     ///     if let Ok(ref mut mutex) = lock {
 253     ///         **mutex = 10;
 254     ///     } else {
 255     ///         println!("try_lock failed");
 256     ///     }
 257     /// }).join().expect("thread::spawn failed");
 258     /// assert_eq!(*mutex.lock().unwrap(), 10);
 259     /// ```
 260     #[stable(feature = "rust1", since = "1.0.0")]
 261     pub fn try_lock(&self) -> TryLockResult<MutexGuard<T>> {
 262         unsafe {
 263             if self.inner.try_lock() {
 264                 Ok(MutexGuard::new(self)?)
 265             } else {
 266                 Err(TryLockError::WouldBlock)
 267             }
 268         }
 269     }
 270
 271     /// Determines whether the mutex is poisoned.
 272     ///
 273     /// If another thread is active, the mutex can still become poisoned at any
 274     /// time. You should not trust a `false` value for program correctness
 275     /// without additional synchronization.
 276     ///
 277     /// # Examples
 278     ///
 279     /// ```
 280     /// use std::sync::{Arc, Mutex};
 281     /// use std::thread;
 282     ///
 283     /// let mutex = Arc::new(Mutex::new(0));
 284     /// let c_mutex = mutex.clone();
 285     ///
 286     /// let _ = thread::spawn(move || {
 287     ///     let _lock = c_mutex.lock().unwrap();
 288     ///     panic!(); // the mutex gets poisoned
 289     /// }).join();
 290     /// assert_eq!(mutex.is_poisoned(), true);
 291     /// ```
 292     #[inline]
 293     #[stable(feature = "sync_poison", since = "1.2.0")]
 294     pub fn is_poisoned(&self) -> bool {
 295         self.poison.get()
 296     }
 297
 298     /// Consumes this mutex, returning the underlying data.
 299     ///
 300     /// # Errors
 301     ///
 302     /// If another user of this mutex panicked while holding the mutex, then
 303     /// this call will return an error instead.
 304     ///
 305     /// # Examples
 306     ///
 307     /// ```
 308     /// use std::sync::Mutex;
 309     ///
 310     /// let mutex = Mutex::new(0);
 311     /// assert_eq!(mutex.into_inner().unwrap(), 0);
 312     /// ```
 313     #[stable(feature = "mutex_into_inner", since = "1.6.0")]
 314     pub fn into_inner(self) -> LockResult<T> where T: Sized {
 315         // We know statically that there are no outstanding references to
 316         // `self` so there's no need to lock the inner mutex.
 317         //
 318         // To get the inner value, we'd like to call `data.into_inner()`,
 319         // but because `Mutex` impl-s `Drop`, we can't move out of it, so
 320         // we'll have to destructure it manually instead.
 321         unsafe {
 322             // Like `let Mutex { inner, poison, data } = self`.
 323             let (inner, poison, data) = {
 324                 let Mutex { ref inner, ref poison, ref data } = self;
 325                 (ptr::read(inner), ptr::read(poison), ptr::read(data))
 326             };
 327             mem::forget(self);
 328             inner.destroy();  // Keep in sync with the `Drop` impl.
 329             drop(inner);
 330
 331             poison::map_result(poison.borrow(), |_| data.into_inner())
 332         }
 333     }
 334
 335     /// Returns a mutable reference to the underlying data.
 336     ///
 337     /// Since this call borrows the `Mutex` mutably, no actual locking needs to
 338     /// take place---the mutable borrow statically guarantees no locks exist.
 339     ///
 340     /// # Errors
 341     ///
 342     /// If another user of this mutex panicked while holding the mutex, then
 343     /// this call will return an error instead.
 344     ///
 345     /// # Examples
 346     ///
 347     /// ```
 348     /// use std::sync::Mutex;
 349     ///
 350     /// let mut mutex = Mutex::new(0);
 351     /// *mutex.get_mut().unwrap() = 10;
 352     /// assert_eq!(*mutex.lock().unwrap(), 10);
 353     /// ```
 354     #[stable(feature = "mutex_get_mut", since = "1.6.0")]
 355     pub fn get_mut(&mut self) -> LockResult<&mut T> {
 356         // We know statically that there are no other references to `self`, so
 357         // there's no need to lock the inner mutex.
 358         let data = unsafe { &mut *self.data.get() };
 359         poison::map_result(self.poison.borrow(), |_| data )
 360     }
 361 }
 362
 363 #[stable(feature = "rust1", since = "1.0.0")]
 364 unsafe impl<#[may_dangle] T: ?Sized> Drop for Mutex<T> {
 365     fn drop(&mut self) {
 366         // This is actually safe b/c we know that there is no further usage of
 367         // this mutex (it's up to the user to arrange for a mutex to get
 368         // dropped, that's not our job)
 369         //
 370         // IMPORTANT: This code must be kept in sync with `Mutex::into_inner`.
 371         unsafe { self.inner.destroy() }
 372     }
 373 }
 374
 375 #[stable(feature = "mutex_from", since = "1.24.0")]
 376 impl<T> From<T> for Mutex<T> {
 377     /// Creates a new mutex in an unlocked state ready for use.
 378     /// This is equivalent to [`Mutex::new`].
 379     fn from(t: T) -> Self {
 380         Mutex::new(t)
 381     }
 382 }
 383
 384 #[stable(feature = "mutex_default", since = "1.10.0")]
 385 impl<T: ?Sized + Default> Default for Mutex<T> {
 386     /// Creates a `Mutex<T>`, with the `Default` value for T.
 387     fn default() -> Mutex<T> {
 388         Mutex::new(Default::default())
 389     }
 390 }
 391
 392 #[stable(feature = "rust1", since = "1.0.0")]
 393 impl<T: ?Sized + fmt::Debug> fmt::Debug for Mutex<T> {
 394     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 395         match self.try_lock() {
 396             Ok(guard) => f.debug_struct("Mutex").field("data", &&*guard).finish(),
 397             Err(TryLockError::Poisoned(err)) => {
 398                 f.debug_struct("Mutex").field("data", &&**err.get_ref()).finish()
 399             },
 400             Err(TryLockError::WouldBlock) => {
 401                 struct LockedPlaceholder;
 402                 impl fmt::Debug for LockedPlaceholder {
 403                     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("<locked>") }
 404                 }
 405
 406                 f.debug_struct("Mutex").field("data", &LockedPlaceholder).finish()
 407             }
 408         }
 409     }
 410 }
 411
 412 impl<'mutex, T: ?Sized> MutexGuard<'mutex, T> {
 413     unsafe fn new(lock: &'mutex Mutex<T>) -> LockResult<MutexGuard<'mutex, T>> {
 414         poison::map_result(lock.poison.borrow(), |guard| {
 415             MutexGuard {
 416                 __lock: lock,
 417                 __poison: guard,
 418             }
 419         })
 420     }
 421 }
 422
 423 #[stable(feature = "rust1", since = "1.0.0")]
 424 impl<'mutex, T: ?Sized> Deref for MutexGuard<'mutex, 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<'mutex, T: ?Sized> DerefMut for MutexGuard<'mutex, 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<'a, T: ?Sized> Drop for MutexGuard<'a, 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<'a, T: ?Sized + fmt::Debug> fmt::Debug for MutexGuard<'a, T> {
 452     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 453         struct MutexFmt<'a, T: ?Sized>(&'a MutexGuard<'a, T>);
 454         impl<'a, T: ?Sized + fmt::Debug> fmt::Debug for MutexFmt<'a, T> {
 455             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 456                 f.debug_struct("Mutex").field("data", &&*self.0).finish()
 457             }
 458         }
 459         f.debug_struct("MutexGuard").field("lock", &MutexFmt(self)).finish()
 460     }
 461 }
 462
 463 #[stable(feature = "std_guard_impls", since = "1.20.0")]
 464 impl<'a, T: ?Sized + fmt::Display> fmt::Display for MutexGuard<'a, T> {
 465     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 466         (**self).fmt(f)
 467     }
 468 }
 469
 470 pub fn guard_lock<'a, T: ?Sized>(guard: &MutexGuard<'a, T>) -> &'a sys::Mutex {
 471     &guard.__lock.inner
 472 }
 473
 474 pub fn guard_poison<'a, T: ?Sized>(guard: &MutexGuard<'a, T>) -> &'a poison::Flag {
 475     &guard.__lock.poison
 476 }
 477
 478 #[cfg(all(test, not(target_os = "emscripten")))]
 479 mod tests {
 480     use sync::mpsc::channel;
 481     use sync::{Arc, Mutex, Condvar};
 482     use sync::atomic::{AtomicUsize, Ordering};
 483     use thread;
 484
 485     struct Packet<T>(Arc<(Mutex<T>, Condvar)>);
 486
 487     #[derive(Eq, PartialEq, Debug)]
 488     struct NonCopy(i32);
 489
 490     #[test]
 491     fn smoke() {
 492         let m = Mutex::new(());
 493         drop(m.lock().unwrap());
 494         drop(m.lock().unwrap());
 495     }
 496
 497     #[test]
 498     fn lots_and_lots() {
 499         const J: u32 = 1000;
 500         const K: u32 = 3;
 501
 502         let m = Arc::new(Mutex::new(0));
 503
 504         fn inc(m: &Mutex<u32>) {
 505             for _ in 0..J {
 506                 *m.lock().unwrap() += 1;
 507             }
 508         }
 509
 510         let (tx, rx) = channel();
 511         for _ in 0..K {
 512             let tx2 = tx.clone();
 513             let m2 = m.clone();
 514             thread::spawn(move|| { inc(&m2); tx2.send(()).unwrap(); });
 515             let tx2 = tx.clone();
 516             let m2 = m.clone();
 517             thread::spawn(move|| { inc(&m2); tx2.send(()).unwrap(); });
 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         }).join();
 565
 566         assert!(m.is_poisoned());
 567         match Arc::try_unwrap(m).unwrap().into_inner() {
 568             Err(e) => assert_eq!(e.into_inner(), NonCopy(10)),
 569             Ok(x) => panic!("into_inner of poisoned Mutex is Ok: {:?}", x),
 570         }
 571     }
 572
 573     #[test]
 574     fn test_get_mut() {
 575         let mut m = Mutex::new(NonCopy(10));
 576         *m.get_mut().unwrap() = NonCopy(20);
 577         assert_eq!(m.into_inner().unwrap(), NonCopy(20));
 578     }
 579
 580     #[test]
 581     fn test_get_mut_poison() {
 582         let m = Arc::new(Mutex::new(NonCopy(10)));
 583         let m2 = m.clone();
 584         let _ = thread::spawn(move || {
 585             let _lock = m2.lock().unwrap();
 586             panic!("test panic in inner thread to poison mutex");
 587         }).join();
 588
 589         assert!(m.is_poisoned());
 590         match Arc::try_unwrap(m).unwrap().get_mut() {
 591             Err(e) => assert_eq!(*e.into_inner(), NonCopy(10)),
 592             Ok(x) => panic!("get_mut of poisoned Mutex is Ok: {:?}", x),
 593         }
 594     }
 595
 596     #[test]
 597     fn test_mutex_arc_condvar() {
 598         let packet = Packet(Arc::new((Mutex::new(false), Condvar::new())));
 599         let packet2 = Packet(packet.0.clone());
 600         let (tx, rx) = channel();
 601         let _t = thread::spawn(move|| {
 602             // wait until parent gets in
 603             rx.recv().unwrap();
 604             let &(ref lock, ref cvar) = &*packet2.0;
 605             let mut lock = lock.lock().unwrap();
 606             *lock = true;
 607             cvar.notify_one();
 608         });
 609
 610         let &(ref lock, ref cvar) = &*packet.0;
 611         let mut lock = lock.lock().unwrap();
 612         tx.send(()).unwrap();
 613         assert!(!*lock);
 614         while !*lock {
 615             lock = cvar.wait(lock).unwrap();
 616         }
 617     }
 618
 619     #[test]
 620     fn test_arc_condvar_poison() {
 621         let packet = Packet(Arc::new((Mutex::new(1), Condvar::new())));
 622         let packet2 = Packet(packet.0.clone());
 623         let (tx, rx) = channel();
 624
 625         let _t = thread::spawn(move || -> () {
 626             rx.recv().unwrap();
 627             let &(ref lock, ref cvar) = &*packet2.0;
 628             let _g = lock.lock().unwrap();
 629             cvar.notify_one();
 630             // Parent should fail when it wakes up.
 631             panic!();
 632         });
 633
 634         let &(ref lock, ref cvar) = &*packet.0;
 635         let mut lock = lock.lock().unwrap();
 636         tx.send(()).unwrap();
 637         while *lock == 1 {
 638             match cvar.wait(lock) {
 639                 Ok(l) => {
 640                     lock = l;
 641                     assert_eq!(*lock, 1);
 642                 }
 643                 Err(..) => break,
 644             }
 645         }
 646     }
 647
 648     #[test]
 649     fn test_mutex_arc_poison() {
 650         let arc = Arc::new(Mutex::new(1));
 651         assert!(!arc.is_poisoned());
 652         let arc2 = arc.clone();
 653         let _ = thread::spawn(move|| {
 654             let lock = arc2.lock().unwrap();
 655             assert_eq!(*lock, 2);
 656         }).join();
 657         assert!(arc.lock().is_err());
 658         assert!(arc.is_poisoned());
 659     }
 660
 661     #[test]
 662     fn test_mutex_arc_nested() {
 663         // Tests nested mutexes and access
 664         // to underlying data.
 665         let arc = Arc::new(Mutex::new(1));
 666         let arc2 = Arc::new(Mutex::new(arc));
 667         let (tx, rx) = channel();
 668         let _t = thread::spawn(move|| {
 669             let lock = arc2.lock().unwrap();
 670             let lock2 = lock.lock().unwrap();
 671             assert_eq!(*lock2, 1);
 672             tx.send(()).unwrap();
 673         });
 674         rx.recv().unwrap();
 675     }
 676
 677     #[test]
 678     fn test_mutex_arc_access_in_unwind() {
 679         let arc = Arc::new(Mutex::new(1));
 680         let arc2 = arc.clone();
 681         let _ = thread::spawn(move|| -> () {
 682             struct Unwinder {
 683                 i: Arc<Mutex<i32>>,
 684             }
 685             impl Drop for Unwinder {
 686                 fn drop(&mut self) {
 687                     *self.i.lock().unwrap() += 1;
 688                 }
 689             }
 690             let _u = Unwinder { i: arc2 };
 691             panic!();
 692         }).join();
 693         let lock = arc.lock().unwrap();
 694         assert_eq!(*lock, 2);
 695     }
 696
 697     #[test]
 698     fn test_mutex_unsized() {
 699         let mutex: &Mutex<[i32]> = &Mutex::new([1, 2, 3]);
 700         {
 701             let b = &mut *mutex.lock().unwrap();
 702             b[0] = 4;
 703             b[2] = 5;
 704         }
 705         let comp: &[i32] = &[4, 2, 5];
 706         assert_eq!(&*mutex.lock().unwrap(), comp);
 707     }
 708 }