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 ///
 111 /// It is sometimes a good idea (or even necessary) to manually drop the mutex
 112 /// to unlock it as soon as possible. If you need the resource until the end of
 113 /// the scope, this is not needed.
 114 ///
 115 /// ```
 116 /// use std::sync::{Arc, Mutex};
 117 /// use std::thread;
 118 ///
 119 /// const N: usize = 3;
 120 ///
 121 /// // Some data to work with in multiple threads.
 122 /// let data_mutex = Arc::new(Mutex::new(vec![1, 2, 3, 4]));
 123 /// // The result of all the work across all threads.
 124 /// let res_mutex = Arc::new(Mutex::new(0));
 125 ///
 126 /// // Threads other than the main thread.
 127 /// let mut threads = Vec::with_capacity(N);
 128 /// (0..N).for_each(|_| {
 129 ///     // Getting clones for the mutexes.
 130 ///     let data_mutex_clone = Arc::clone(&data_mutex);
 131 ///     let res_mutex_clone = Arc::clone(&res_mutex);
 132 ///
 133 ///     threads.push(thread::spawn(move || {
 134 ///         let mut data = data_mutex_clone.lock().unwrap();
 135 ///         // This is the result of some important and long-ish work.
 136 ///         let result = data.iter().fold(0, |acc, x| acc + x * 2);
 137 ///         data.push(result);
 138 ///         // We drop the `data` explicitely because it's not necessary anymore
 139 ///         // and the thread still has work to do. This allow other threads to
 140 ///         // start working on the data immediately, without waiting
 141 ///         // for the rest of the unrelated work to be done here.
 142 ///         drop(data);
 143 ///         *res_mutex_clone.lock().unwrap() += result;
 144 ///     }));
 145 /// });
 146 ///
 147 /// let mut data = data_mutex.lock().unwrap();
 148 /// // This is the result of some important and long-ish work.
 149 /// let result = data.iter().fold(0, |acc, x| acc + x * 2);
 150 /// data.push(result);
 151 /// // We drop the `data` explicitely because it's not necessary anymore
 152 /// // and the thread still has work to do. This allow other threads to
 153 /// // start working on the data immediately, without waiting
 154 /// // for the rest of the unrelated work to be done here.
 155 /// //
 156 /// // It's even more important here because we `.join` the threads after that.
 157 /// // If we had not dropped the lock, a thread could be waiting forever for
 158 /// // it, causing a deadlock.
 159 /// drop(data);
 160 /// // Here the lock is not assigned to a variable and so, even if the scope
 161 /// // does not end after this line, the mutex is still released:
 162 /// // there is no deadlock.
 163 /// *res_mutex.lock().unwrap() += result;
 164 ///
 165 /// threads.into_iter().for_each(|thread| {
 166 ///     thread
 167 ///         .join()
 168 ///         .expect("The thread creating or execution failed !")
 169 /// });
 170 ///
 171 /// assert_eq!(*res_mutex.lock().unwrap(), 800);
 172 /// ```
 173 #[stable(feature = "rust1", since = "1.0.0")]
 174 #[cfg_attr(not(test), rustc_diagnostic_item = "mutex_type")]
 175 pub struct Mutex<T: ?Sized> {
 176     // Note that this mutex is in a *box*, not inlined into the struct itself.
 177     // Once a native mutex has been used once, its address can never change (it
 178     // can't be moved). This mutex type can be safely moved at any time, so to
 179     // ensure that the native mutex is used correctly we box the inner mutex to
 180     // give it a constant address.
 181     inner: Box<sys::Mutex>,
 182     poison: poison::Flag,
 183     data: UnsafeCell<T>,
 184 }
 185
 186 // these are the only places where `T: Send` matters; all other
 187 // functionality works fine on a single thread.
 188 #[stable(feature = "rust1", since = "1.0.0")]
 189 unsafe impl<T: ?Sized + Send> Send for Mutex<T> {}
 190 #[stable(feature = "rust1", since = "1.0.0")]
 191 unsafe impl<T: ?Sized + Send> Sync for Mutex<T> {}
 192
 193 /// An RAII implementation of a "scoped lock" of a mutex. When this structure is
 194 /// dropped (falls out of scope), the lock will be unlocked.
 195 ///
 196 /// The data protected by the mutex can be accessed through this guard via its
 197 /// [`Deref`] and [`DerefMut`] implementations.
 198 ///
 199 /// This structure is created by the [`lock`] and [`try_lock`] methods on
 200 /// [`Mutex`].
 201 ///
 202 /// [`Deref`]: ../../std/ops/trait.Deref.html
 203 /// [`DerefMut`]: ../../std/ops/trait.DerefMut.html
 204 /// [`lock`]: struct.Mutex.html#method.lock
 205 /// [`try_lock`]: struct.Mutex.html#method.try_lock
 206 /// [`Mutex`]: struct.Mutex.html
 207 #[must_use = "if unused the Mutex will immediately unlock"]
 208 #[stable(feature = "rust1", since = "1.0.0")]
 209 pub struct MutexGuard<'a, T: ?Sized + 'a> {
 210     lock: &'a Mutex<T>,
 211     poison: poison::Guard,
 212 }
 213
 214 #[stable(feature = "rust1", since = "1.0.0")]
 215 impl<T: ?Sized> !Send for MutexGuard<'_, T> {}
 216 #[stable(feature = "mutexguard", since = "1.19.0")]
 217 unsafe impl<T: ?Sized + Sync> Sync for MutexGuard<'_, T> {}
 218
 219 impl<T> Mutex<T> {
 220     /// Creates a new mutex in an unlocked state ready for use.
 221     ///
 222     /// # Examples
 223     ///
 224     /// ```
 225     /// use std::sync::Mutex;
 226     ///
 227     /// let mutex = Mutex::new(0);
 228     /// ```
 229     #[stable(feature = "rust1", since = "1.0.0")]
 230     pub fn new(t: T) -> Mutex<T> {
 231         let mut m = Mutex {
 232             inner: box sys::Mutex::new(),
 233             poison: poison::Flag::new(),
 234             data: UnsafeCell::new(t),
 235         };
 236         unsafe {
 237             m.inner.init();
 238         }
 239         m
 240     }
 241 }
 242
 243 impl<T: ?Sized> Mutex<T> {
 244     /// Acquires a mutex, blocking the current thread until it is able to do so.
 245     ///
 246     /// This function will block the local thread until it is available to acquire
 247     /// the mutex. Upon returning, the thread is the only thread with the lock
 248     /// held. An RAII guard is returned to allow scoped unlock of the lock. When
 249     /// the guard goes out of scope, the mutex will be unlocked.
 250     ///
 251     /// The exact behavior on locking a mutex in the thread which already holds
 252     /// the lock is left unspecified. However, this function will not return on
 253     /// the second call (it might panic or deadlock, for example).
 254     ///
 255     /// # Errors
 256     ///
 257     /// If another user of this mutex panicked while holding the mutex, then
 258     /// this call will return an error once the mutex is acquired.
 259     ///
 260     /// # Panics
 261     ///
 262     /// This function might panic when called if the lock is already held by
 263     /// the current thread.
 264     ///
 265     /// # Examples
 266     ///
 267     /// ```
 268     /// use std::sync::{Arc, Mutex};
 269     /// use std::thread;
 270     ///
 271     /// let mutex = Arc::new(Mutex::new(0));
 272     /// let c_mutex = mutex.clone();
 273     ///
 274     /// thread::spawn(move || {
 275     ///     *c_mutex.lock().unwrap() = 10;
 276     /// }).join().expect("thread::spawn failed");
 277     /// assert_eq!(*mutex.lock().unwrap(), 10);
 278     /// ```
 279     #[stable(feature = "rust1", since = "1.0.0")]
 280     pub fn lock(&self) -> LockResult<MutexGuard<'_, T>> {
 281         unsafe {
 282             self.inner.raw_lock();
 283             MutexGuard::new(self)
 284         }
 285     }
 286
 287     /// Attempts to acquire this lock.
 288     ///
 289     /// If the lock could not be acquired at this time, then [`Err`] is returned.
 290     /// Otherwise, an RAII guard is returned. The lock will be unlocked when the
 291     /// guard is dropped.
 292     ///
 293     /// This function does not block.
 294     ///
 295     /// # Errors
 296     ///
 297     /// If another user of this mutex panicked while holding the mutex, then
 298     /// this call will return failure if the mutex would otherwise be
 299     /// acquired.
 300     ///
 301     /// [`Err`]: ../../std/result/enum.Result.html#variant.Err
 302     ///
 303     /// # Examples
 304     ///
 305     /// ```
 306     /// use std::sync::{Arc, Mutex};
 307     /// use std::thread;
 308     ///
 309     /// let mutex = Arc::new(Mutex::new(0));
 310     /// let c_mutex = mutex.clone();
 311     ///
 312     /// thread::spawn(move || {
 313     ///     let mut lock = c_mutex.try_lock();
 314     ///     if let Ok(ref mut mutex) = lock {
 315     ///         **mutex = 10;
 316     ///     } else {
 317     ///         println!("try_lock failed");
 318     ///     }
 319     /// }).join().expect("thread::spawn failed");
 320     /// assert_eq!(*mutex.lock().unwrap(), 10);
 321     /// ```
 322     #[stable(feature = "rust1", since = "1.0.0")]
 323     pub fn try_lock(&self) -> TryLockResult<MutexGuard<'_, T>> {
 324         unsafe {
 325             if self.inner.try_lock() {
 326                 Ok(MutexGuard::new(self)?)
 327             } else {
 328                 Err(TryLockError::WouldBlock)
 329             }
 330         }
 331     }
 332
 333     /// Determines whether the mutex is poisoned.
 334     ///
 335     /// If another thread is active, the mutex can still become poisoned at any
 336     /// time. You should not trust a `false` value for program correctness
 337     /// without additional synchronization.
 338     ///
 339     /// # Examples
 340     ///
 341     /// ```
 342     /// use std::sync::{Arc, Mutex};
 343     /// use std::thread;
 344     ///
 345     /// let mutex = Arc::new(Mutex::new(0));
 346     /// let c_mutex = mutex.clone();
 347     ///
 348     /// let _ = thread::spawn(move || {
 349     ///     let _lock = c_mutex.lock().unwrap();
 350     ///     panic!(); // the mutex gets poisoned
 351     /// }).join();
 352     /// assert_eq!(mutex.is_poisoned(), true);
 353     /// ```
 354     #[inline]
 355     #[stable(feature = "sync_poison", since = "1.2.0")]
 356     pub fn is_poisoned(&self) -> bool {
 357         self.poison.get()
 358     }
 359
 360     /// Consumes this mutex, returning the underlying data.
 361     ///
 362     /// # Errors
 363     ///
 364     /// If another user of this mutex panicked while holding the mutex, then
 365     /// this call will return an error instead.
 366     ///
 367     /// # Examples
 368     ///
 369     /// ```
 370     /// use std::sync::Mutex;
 371     ///
 372     /// let mutex = Mutex::new(0);
 373     /// assert_eq!(mutex.into_inner().unwrap(), 0);
 374     /// ```
 375     #[stable(feature = "mutex_into_inner", since = "1.6.0")]
 376     pub fn into_inner(self) -> LockResult<T>
 377     where
 378         T: Sized,
 379     {
 380         // We know statically that there are no outstanding references to
 381         // `self` so there's no need to lock the inner mutex.
 382         //
 383         // To get the inner value, we'd like to call `data.into_inner()`,
 384         // but because `Mutex` impl-s `Drop`, we can't move out of it, so
 385         // we'll have to destructure it manually instead.
 386         unsafe {
 387             // Like `let Mutex { inner, poison, data } = self`.
 388             let (inner, poison, data) = {
 389                 let Mutex { ref inner, ref poison, ref data } = self;
 390                 (ptr::read(inner), ptr::read(poison), ptr::read(data))
 391             };
 392             mem::forget(self);
 393             inner.destroy(); // Keep in sync with the `Drop` impl.
 394             drop(inner);
 395
 396             poison::map_result(poison.borrow(), |_| data.into_inner())
 397         }
 398     }
 399
 400     /// Returns a mutable reference to the underlying data.
 401     ///
 402     /// Since this call borrows the `Mutex` mutably, no actual locking needs to
 403     /// take place -- the mutable borrow statically guarantees no locks exist.
 404     ///
 405     /// # Errors
 406     ///
 407     /// If another user of this mutex panicked while holding the mutex, then
 408     /// this call will return an error instead.
 409     ///
 410     /// # Examples
 411     ///
 412     /// ```
 413     /// use std::sync::Mutex;
 414     ///
 415     /// let mut mutex = Mutex::new(0);
 416     /// *mutex.get_mut().unwrap() = 10;
 417     /// assert_eq!(*mutex.lock().unwrap(), 10);
 418     /// ```
 419     #[stable(feature = "mutex_get_mut", since = "1.6.0")]
 420     pub fn get_mut(&mut self) -> LockResult<&mut T> {
 421         // We know statically that there are no other references to `self`, so
 422         // there's no need to lock the inner mutex.
 423         let data = unsafe { &mut *self.data.get() };
 424         poison::map_result(self.poison.borrow(), |_| data)
 425     }
 426 }
 427
 428 #[stable(feature = "rust1", since = "1.0.0")]
 429 unsafe impl<#[may_dangle] T: ?Sized> Drop for Mutex<T> {
 430     fn drop(&mut self) {
 431         // This is actually safe b/c we know that there is no further usage of
 432         // this mutex (it's up to the user to arrange for a mutex to get
 433         // dropped, that's not our job)
 434         //
 435         // IMPORTANT: This code must be kept in sync with `Mutex::into_inner`.
 436         unsafe { self.inner.destroy() }
 437     }
 438 }
 439
 440 #[stable(feature = "mutex_from", since = "1.24.0")]
 441 impl<T> From<T> for Mutex<T> {
 442     /// Creates a new mutex in an unlocked state ready for use.
 443     /// This is equivalent to [`Mutex::new`].
 444     ///
 445     /// [`Mutex::new`]: ../../std/sync/struct.Mutex.html#method.new
 446     fn from(t: T) -> Self {
 447         Mutex::new(t)
 448     }
 449 }
 450
 451 #[stable(feature = "mutex_default", since = "1.10.0")]
 452 impl<T: ?Sized + Default> Default for Mutex<T> {
 453     /// Creates a `Mutex<T>`, with the `Default` value for T.
 454     fn default() -> Mutex<T> {
 455         Mutex::new(Default::default())
 456     }
 457 }
 458
 459 #[stable(feature = "rust1", since = "1.0.0")]
 460 impl<T: ?Sized + fmt::Debug> fmt::Debug for Mutex<T> {
 461     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 462         match self.try_lock() {
 463             Ok(guard) => f.debug_struct("Mutex").field("data", &&*guard).finish(),
 464             Err(TryLockError::Poisoned(err)) => {
 465                 f.debug_struct("Mutex").field("data", &&**err.get_ref()).finish()
 466             }
 467             Err(TryLockError::WouldBlock) => {
 468                 struct LockedPlaceholder;
 469                 impl fmt::Debug for LockedPlaceholder {
 470                     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 471                         f.write_str("<locked>")
 472                     }
 473                 }
 474
 475                 f.debug_struct("Mutex").field("data", &LockedPlaceholder).finish()
 476             }
 477         }
 478     }
 479 }
 480
 481 impl<'mutex, T: ?Sized> MutexGuard<'mutex, T> {
 482     unsafe fn new(lock: &'mutex Mutex<T>) -> LockResult<MutexGuard<'mutex, T>> {
 483         poison::map_result(lock.poison.borrow(), |guard| MutexGuard { lock, poison: guard })
 484     }
 485 }
 486
 487 #[stable(feature = "rust1", since = "1.0.0")]
 488 impl<T: ?Sized> Deref for MutexGuard<'_, T> {
 489     type Target = T;
 490
 491     fn deref(&self) -> &T {
 492         unsafe { &*self.lock.data.get() }
 493     }
 494 }
 495
 496 #[stable(feature = "rust1", since = "1.0.0")]
 497 impl<T: ?Sized> DerefMut for MutexGuard<'_, T> {
 498     fn deref_mut(&mut self) -> &mut T {
 499         unsafe { &mut *self.lock.data.get() }
 500     }
 501 }
 502
 503 #[stable(feature = "rust1", since = "1.0.0")]
 504 impl<T: ?Sized> Drop for MutexGuard<'_, T> {
 505     #[inline]
 506     fn drop(&mut self) {
 507         unsafe {
 508             self.lock.poison.done(&self.poison);
 509             self.lock.inner.raw_unlock();
 510         }
 511     }
 512 }
 513
 514 #[stable(feature = "std_debug", since = "1.16.0")]
 515 impl<T: ?Sized + fmt::Debug> fmt::Debug for MutexGuard<'_, T> {
 516     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 517         fmt::Debug::fmt(&**self, f)
 518     }
 519 }
 520
 521 #[stable(feature = "std_guard_impls", since = "1.20.0")]
 522 impl<T: ?Sized + fmt::Display> fmt::Display for MutexGuard<'_, T> {
 523     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 524         (**self).fmt(f)
 525     }
 526 }
 527
 528 pub fn guard_lock<'a, T: ?Sized>(guard: &MutexGuard<'a, T>) -> &'a sys::Mutex {
 529     &guard.lock.inner
 530 }
 531
 532 pub fn guard_poison<'a, T: ?Sized>(guard: &MutexGuard<'a, T>) -> &'a poison::Flag {
 533     &guard.lock.poison
 534 }
 535
 536 #[cfg(all(test, not(target_os = "emscripten")))]
 537 mod tests {
 538     use crate::sync::atomic::{AtomicUsize, Ordering};
 539     use crate::sync::mpsc::channel;
 540     use crate::sync::{Arc, Condvar, Mutex};
 541     use crate::thread;
 542
 543     struct Packet<T>(Arc<(Mutex<T>, Condvar)>);
 544
 545     #[derive(Eq, PartialEq, Debug)]
 546     struct NonCopy(i32);
 547
 548     #[test]
 549     fn smoke() {
 550         let m = Mutex::new(());
 551         drop(m.lock().unwrap());
 552         drop(m.lock().unwrap());
 553     }
 554
 555     #[test]
 556     fn lots_and_lots() {
 557         const J: u32 = 1000;
 558         const K: u32 = 3;
 559
 560         let m = Arc::new(Mutex::new(0));
 561
 562         fn inc(m: &Mutex<u32>) {
 563             for _ in 0..J {
 564                 *m.lock().unwrap() += 1;
 565             }
 566         }
 567
 568         let (tx, rx) = channel();
 569         for _ in 0..K {
 570             let tx2 = tx.clone();
 571             let m2 = m.clone();
 572             thread::spawn(move || {
 573                 inc(&m2);
 574                 tx2.send(()).unwrap();
 575             });
 576             let tx2 = tx.clone();
 577             let m2 = m.clone();
 578             thread::spawn(move || {
 579                 inc(&m2);
 580                 tx2.send(()).unwrap();
 581             });
 582         }
 583
 584         drop(tx);
 585         for _ in 0..2 * K {
 586             rx.recv().unwrap();
 587         }
 588         assert_eq!(*m.lock().unwrap(), J * K * 2);
 589     }
 590
 591     #[test]
 592     fn try_lock() {
 593         let m = Mutex::new(());
 594         *m.try_lock().unwrap() = ();
 595     }
 596
 597     #[test]
 598     fn test_into_inner() {
 599         let m = Mutex::new(NonCopy(10));
 600         assert_eq!(m.into_inner().unwrap(), NonCopy(10));
 601     }
 602
 603     #[test]
 604     fn test_into_inner_drop() {
 605         struct Foo(Arc<AtomicUsize>);
 606         impl Drop for Foo {
 607             fn drop(&mut self) {
 608                 self.0.fetch_add(1, Ordering::SeqCst);
 609             }
 610         }
 611         let num_drops = Arc::new(AtomicUsize::new(0));
 612         let m = Mutex::new(Foo(num_drops.clone()));
 613         assert_eq!(num_drops.load(Ordering::SeqCst), 0);
 614         {
 615             let _inner = m.into_inner().unwrap();
 616             assert_eq!(num_drops.load(Ordering::SeqCst), 0);
 617         }
 618         assert_eq!(num_drops.load(Ordering::SeqCst), 1);
 619     }
 620
 621     #[test]
 622     fn test_into_inner_poison() {
 623         let m = Arc::new(Mutex::new(NonCopy(10)));
 624         let m2 = m.clone();
 625         let _ = thread::spawn(move || {
 626             let _lock = m2.lock().unwrap();
 627             panic!("test panic in inner thread to poison mutex");
 628         })
 629         .join();
 630
 631         assert!(m.is_poisoned());
 632         match Arc::try_unwrap(m).unwrap().into_inner() {
 633             Err(e) => assert_eq!(e.into_inner(), NonCopy(10)),
 634             Ok(x) => panic!("into_inner of poisoned Mutex is Ok: {:?}", x),
 635         }
 636     }
 637
 638     #[test]
 639     fn test_get_mut() {
 640         let mut m = Mutex::new(NonCopy(10));
 641         *m.get_mut().unwrap() = NonCopy(20);
 642         assert_eq!(m.into_inner().unwrap(), NonCopy(20));
 643     }
 644
 645     #[test]
 646     fn test_get_mut_poison() {
 647         let m = Arc::new(Mutex::new(NonCopy(10)));
 648         let m2 = m.clone();
 649         let _ = thread::spawn(move || {
 650             let _lock = m2.lock().unwrap();
 651             panic!("test panic in inner thread to poison mutex");
 652         })
 653         .join();
 654
 655         assert!(m.is_poisoned());
 656         match Arc::try_unwrap(m).unwrap().get_mut() {
 657             Err(e) => assert_eq!(*e.into_inner(), NonCopy(10)),
 658             Ok(x) => panic!("get_mut of poisoned Mutex is Ok: {:?}", x),
 659         }
 660     }
 661
 662     #[test]
 663     fn test_mutex_arc_condvar() {
 664         let packet = Packet(Arc::new((Mutex::new(false), Condvar::new())));
 665         let packet2 = Packet(packet.0.clone());
 666         let (tx, rx) = channel();
 667         let _t = thread::spawn(move || {
 668             // wait until parent gets in
 669             rx.recv().unwrap();
 670             let &(ref lock, ref cvar) = &*packet2.0;
 671             let mut lock = lock.lock().unwrap();
 672             *lock = true;
 673             cvar.notify_one();
 674         });
 675
 676         let &(ref lock, ref cvar) = &*packet.0;
 677         let mut lock = lock.lock().unwrap();
 678         tx.send(()).unwrap();
 679         assert!(!*lock);
 680         while !*lock {
 681             lock = cvar.wait(lock).unwrap();
 682         }
 683     }
 684
 685     #[test]
 686     fn test_arc_condvar_poison() {
 687         let packet = Packet(Arc::new((Mutex::new(1), Condvar::new())));
 688         let packet2 = Packet(packet.0.clone());
 689         let (tx, rx) = channel();
 690
 691         let _t = thread::spawn(move || -> () {
 692             rx.recv().unwrap();
 693             let &(ref lock, ref cvar) = &*packet2.0;
 694             let _g = lock.lock().unwrap();
 695             cvar.notify_one();
 696             // Parent should fail when it wakes up.
 697             panic!();
 698         });
 699
 700         let &(ref lock, ref cvar) = &*packet.0;
 701         let mut lock = lock.lock().unwrap();
 702         tx.send(()).unwrap();
 703         while *lock == 1 {
 704             match cvar.wait(lock) {
 705                 Ok(l) => {
 706                     lock = l;
 707                     assert_eq!(*lock, 1);
 708                 }
 709                 Err(..) => break,
 710             }
 711         }
 712     }
 713
 714     #[test]
 715     fn test_mutex_arc_poison() {
 716         let arc = Arc::new(Mutex::new(1));
 717         assert!(!arc.is_poisoned());
 718         let arc2 = arc.clone();
 719         let _ = thread::spawn(move || {
 720             let lock = arc2.lock().unwrap();
 721             assert_eq!(*lock, 2);
 722         })
 723         .join();
 724         assert!(arc.lock().is_err());
 725         assert!(arc.is_poisoned());
 726     }
 727
 728     #[test]
 729     fn test_mutex_arc_nested() {
 730         // Tests nested mutexes and access
 731         // to underlying data.
 732         let arc = Arc::new(Mutex::new(1));
 733         let arc2 = Arc::new(Mutex::new(arc));
 734         let (tx, rx) = channel();
 735         let _t = thread::spawn(move || {
 736             let lock = arc2.lock().unwrap();
 737             let lock2 = lock.lock().unwrap();
 738             assert_eq!(*lock2, 1);
 739             tx.send(()).unwrap();
 740         });
 741         rx.recv().unwrap();
 742     }
 743
 744     #[test]
 745     fn test_mutex_arc_access_in_unwind() {
 746         let arc = Arc::new(Mutex::new(1));
 747         let arc2 = arc.clone();
 748         let _ = thread::spawn(move || -> () {
 749             struct Unwinder {
 750                 i: Arc<Mutex<i32>>,
 751             }
 752             impl Drop for Unwinder {
 753                 fn drop(&mut self) {
 754                     *self.i.lock().unwrap() += 1;
 755                 }
 756             }
 757             let _u = Unwinder { i: arc2 };
 758             panic!();
 759         })
 760         .join();
 761         let lock = arc.lock().unwrap();
 762         assert_eq!(*lock, 2);
 763     }
 764
 765     #[test]
 766     fn test_mutex_unsized() {
 767         let mutex: &Mutex<[i32]> = &Mutex::new([1, 2, 3]);
 768         {
 769             let b = &mut *mutex.lock().unwrap();
 770             b[0] = 4;
 771             b[2] = 5;
 772         }
 773         let comp: &[i32] = &[4, 2, 5];
 774         assert_eq!(&*mutex.lock().unwrap(), comp);
 775     }
 776 }