library/std/src/sync/rwlock.rs

   1 #[cfg(all(test, not(target_os = "emscripten")))]
   2 mod tests;
   3
   4 use crate::cell::UnsafeCell;
   5 use crate::fmt;
   6 use crate::ops::{Deref, DerefMut};
   7 use crate::ptr::NonNull;
   8 use crate::sync::{poison, LockResult, TryLockError, TryLockResult};
   9 use crate::sys_common::rwlock as sys;
  10
  11 /// A reader-writer lock
  12 ///
  13 /// This type of lock allows a number of readers or at most one writer at any
  14 /// point in time. The write portion of this lock typically allows modification
  15 /// of the underlying data (exclusive access) and the read portion of this lock
  16 /// typically allows for read-only access (shared access).
  17 ///
  18 /// In comparison, a [`Mutex`] does not distinguish between readers or writers
  19 /// that acquire the lock, therefore blocking any threads waiting for the lock to
  20 /// become available. An `RwLock` will allow any number of readers to acquire the
  21 /// lock as long as a writer is not holding the lock.
  22 ///
  23 /// The priority policy of the lock is dependent on the underlying operating
  24 /// system's implementation, and this type does not guarantee that any
  25 /// particular policy will be used. In particular, a writer which is waiting to
  26 /// acquire the lock in `write` might or might not block concurrent calls to
  27 /// `read`, e.g.:
  28 ///
  29 /// <details><summary>Potential deadlock example</summary>
  30 ///
  31 /// ```text
  32 /// // Thread 1             |  // Thread 2
  33 /// let _rg = lock.read();  |
  34 ///                         |  // will block
  35 ///                         |  let _wg = lock.write();
  36 /// // may deadlock         |
  37 /// let _rg = lock.read();  |
  38 /// ```
  39 /// </details>
  40 ///
  41 /// The type parameter `T` represents the data that this lock protects. It is
  42 /// required that `T` satisfies [`Send`] to be shared across threads and
  43 /// [`Sync`] to allow concurrent access through readers. The RAII guards
  44 /// returned from the locking methods implement [`Deref`] (and [`DerefMut`]
  45 /// for the `write` methods) to allow access to the content of the lock.
  46 ///
  47 /// # Poisoning
  48 ///
  49 /// An `RwLock`, like [`Mutex`], will become poisoned on a panic. Note, however,
  50 /// that an `RwLock` may only be poisoned if a panic occurs while it is locked
  51 /// exclusively (write mode). If a panic occurs in any reader, then the lock
  52 /// will not be poisoned.
  53 ///
  54 /// # Examples
  55 ///
  56 /// ```
  57 /// use std::sync::RwLock;
  58 ///
  59 /// let lock = RwLock::new(5);
  60 ///
  61 /// // many reader locks can be held at once
  62 /// {
  63 ///     let r1 = lock.read().unwrap();
  64 ///     let r2 = lock.read().unwrap();
  65 ///     assert_eq!(*r1, 5);
  66 ///     assert_eq!(*r2, 5);
  67 /// } // read locks are dropped at this point
  68 ///
  69 /// // only one write lock may be held, however
  70 /// {
  71 ///     let mut w = lock.write().unwrap();
  72 ///     *w += 1;
  73 ///     assert_eq!(*w, 6);
  74 /// } // write lock is dropped here
  75 /// ```
  76 ///
  77 /// [`Mutex`]: super::Mutex
  78 #[stable(feature = "rust1", since = "1.0.0")]
  79 #[cfg_attr(not(test), rustc_diagnostic_item = "RwLock")]
  80 pub struct RwLock<T: ?Sized> {
  81     inner: sys::MovableRwLock,
  82     poison: poison::Flag,
  83     data: UnsafeCell<T>,
  84 }
  85
  86 #[stable(feature = "rust1", since = "1.0.0")]
  87 unsafe impl<T: ?Sized + Send> Send for RwLock<T> {}
  88 #[stable(feature = "rust1", since = "1.0.0")]
  89 unsafe impl<T: ?Sized + Send + Sync> Sync for RwLock<T> {}
  90
  91 /// RAII structure used to release the shared read access of a lock when
  92 /// dropped.
  93 ///
  94 /// This structure is created by the [`read`] and [`try_read`] methods on
  95 /// [`RwLock`].
  96 ///
  97 /// [`read`]: RwLock::read
  98 /// [`try_read`]: RwLock::try_read
  99 #[must_use = "if unused the RwLock will immediately unlock"]
 100 #[must_not_suspend = "holding a RwLockReadGuard across suspend \
 101                       points can cause deadlocks, delays, \
 102                       and cause Futures to not implement `Send`"]
 103 #[stable(feature = "rust1", since = "1.0.0")]
 104 #[clippy::has_significant_drop]
 105 #[cfg_attr(not(test), rustc_diagnostic_item = "RwLockReadGuard")]
 106 pub struct RwLockReadGuard<'a, T: ?Sized + 'a> {
 107     // NB: we use a pointer instead of `&'a T` to avoid `noalias` violations, because a
 108     // `Ref` argument doesn't hold immutability for its whole scope, only until it drops.
 109     // `NonNull` is also covariant over `T`, just like we would have with `&T`. `NonNull`
 110     // is preferable over `const* T` to allow for niche optimization.
 111     data: NonNull<T>,
 112     inner_lock: &'a sys::MovableRwLock,
 113 }
 114
 115 #[stable(feature = "rust1", since = "1.0.0")]
 116 impl<T: ?Sized> !Send for RwLockReadGuard<'_, T> {}
 117
 118 #[stable(feature = "rwlock_guard_sync", since = "1.23.0")]
 119 unsafe impl<T: ?Sized + Sync> Sync for RwLockReadGuard<'_, T> {}
 120
 121 /// RAII structure used to release the exclusive write access of a lock when
 122 /// dropped.
 123 ///
 124 /// This structure is created by the [`write`] and [`try_write`] methods
 125 /// on [`RwLock`].
 126 ///
 127 /// [`write`]: RwLock::write
 128 /// [`try_write`]: RwLock::try_write
 129 #[must_use = "if unused the RwLock will immediately unlock"]
 130 #[must_not_suspend = "holding a RwLockWriteGuard across suspend \
 131                       points can cause deadlocks, delays, \
 132                       and cause Future's to not implement `Send`"]
 133 #[stable(feature = "rust1", since = "1.0.0")]
 134 #[clippy::has_significant_drop]
 135 #[cfg_attr(not(test), rustc_diagnostic_item = "RwLockWriteGuard")]
 136 pub struct RwLockWriteGuard<'a, T: ?Sized + 'a> {
 137     lock: &'a RwLock<T>,
 138     poison: poison::Guard,
 139 }
 140
 141 #[stable(feature = "rust1", since = "1.0.0")]
 142 impl<T: ?Sized> !Send for RwLockWriteGuard<'_, T> {}
 143
 144 #[stable(feature = "rwlock_guard_sync", since = "1.23.0")]
 145 unsafe impl<T: ?Sized + Sync> Sync for RwLockWriteGuard<'_, T> {}
 146
 147 impl<T> RwLock<T> {
 148     /// Creates a new instance of an `RwLock<T>` which is unlocked.
 149     ///
 150     /// # Examples
 151     ///
 152     /// ```
 153     /// use std::sync::RwLock;
 154     ///
 155     /// let lock = RwLock::new(5);
 156     /// ```
 157     #[stable(feature = "rust1", since = "1.0.0")]
 158     #[rustc_const_stable(feature = "const_locks", since = "1.63.0")]
 159     #[inline]
 160     pub const fn new(t: T) -> RwLock<T> {
 161         RwLock {
 162             inner: sys::MovableRwLock::new(),
 163             poison: poison::Flag::new(),
 164             data: UnsafeCell::new(t),
 165         }
 166     }
 167 }
 168
 169 impl<T: ?Sized> RwLock<T> {
 170     /// Locks this `RwLock` with shared read access, blocking the current thread
 171     /// until it can be acquired.
 172     ///
 173     /// The calling thread will be blocked until there are no more writers which
 174     /// hold the lock. There may be other readers currently inside the lock when
 175     /// this method returns. This method does not provide any guarantees with
 176     /// respect to the ordering of whether contentious readers or writers will
 177     /// acquire the lock first.
 178     ///
 179     /// Returns an RAII guard which will release this thread's shared access
 180     /// once it is dropped.
 181     ///
 182     /// # Errors
 183     ///
 184     /// This function will return an error if the `RwLock` is poisoned. An
 185     /// `RwLock` is poisoned whenever a writer panics while holding an exclusive
 186     /// lock. The failure will occur immediately after the lock has been
 187     /// acquired.
 188     ///
 189     /// # Panics
 190     ///
 191     /// This function might panic when called if the lock is already held by the current thread.
 192     ///
 193     /// # Examples
 194     ///
 195     /// ```
 196     /// use std::sync::{Arc, RwLock};
 197     /// use std::thread;
 198     ///
 199     /// let lock = Arc::new(RwLock::new(1));
 200     /// let c_lock = Arc::clone(&lock);
 201     ///
 202     /// let n = lock.read().unwrap();
 203     /// assert_eq!(*n, 1);
 204     ///
 205     /// thread::spawn(move || {
 206     ///     let r = c_lock.read();
 207     ///     assert!(r.is_ok());
 208     /// }).join().unwrap();
 209     /// ```
 210     #[inline]
 211     #[stable(feature = "rust1", since = "1.0.0")]
 212     pub fn read(&self) -> LockResult<RwLockReadGuard<'_, T>> {
 213         unsafe {
 214             self.inner.read();
 215             RwLockReadGuard::new(self)
 216         }
 217     }
 218
 219     /// Attempts to acquire this `RwLock` with shared read access.
 220     ///
 221     /// If the access could not be granted at this time, then `Err` is returned.
 222     /// Otherwise, an RAII guard is returned which will release the shared access
 223     /// when it is dropped.
 224     ///
 225     /// This function does not block.
 226     ///
 227     /// This function does not provide any guarantees with respect to the ordering
 228     /// of whether contentious readers or writers will acquire the lock first.
 229     ///
 230     /// # Errors
 231     ///
 232     /// This function will return the [`Poisoned`] error if the `RwLock` is
 233     /// poisoned. An `RwLock` is poisoned whenever a writer panics while holding
 234     /// an exclusive lock. `Poisoned` will only be returned if the lock would
 235     /// have otherwise been acquired.
 236     ///
 237     /// This function will return the [`WouldBlock`] error if the `RwLock` could
 238     /// not be acquired because it was already locked exclusively.
 239     ///
 240     /// [`Poisoned`]: TryLockError::Poisoned
 241     /// [`WouldBlock`]: TryLockError::WouldBlock
 242     ///
 243     /// # Examples
 244     ///
 245     /// ```
 246     /// use std::sync::RwLock;
 247     ///
 248     /// let lock = RwLock::new(1);
 249     ///
 250     /// match lock.try_read() {
 251     ///     Ok(n) => assert_eq!(*n, 1),
 252     ///     Err(_) => unreachable!(),
 253     /// };
 254     /// ```
 255     #[inline]
 256     #[stable(feature = "rust1", since = "1.0.0")]
 257     pub fn try_read(&self) -> TryLockResult<RwLockReadGuard<'_, T>> {
 258         unsafe {
 259             if self.inner.try_read() {
 260                 Ok(RwLockReadGuard::new(self)?)
 261             } else {
 262                 Err(TryLockError::WouldBlock)
 263             }
 264         }
 265     }
 266
 267     /// Locks this `RwLock` with exclusive write access, blocking the current
 268     /// thread until it can be acquired.
 269     ///
 270     /// This function will not return while other writers or other readers
 271     /// currently have access to the lock.
 272     ///
 273     /// Returns an RAII guard which will drop the write access of this `RwLock`
 274     /// when dropped.
 275     ///
 276     /// # Errors
 277     ///
 278     /// This function will return an error if the `RwLock` is poisoned. An
 279     /// `RwLock` is poisoned whenever a writer panics while holding an exclusive
 280     /// lock. An error will be returned when the lock is acquired.
 281     ///
 282     /// # Panics
 283     ///
 284     /// This function might panic when called if the lock is already held by the current thread.
 285     ///
 286     /// # Examples
 287     ///
 288     /// ```
 289     /// use std::sync::RwLock;
 290     ///
 291     /// let lock = RwLock::new(1);
 292     ///
 293     /// let mut n = lock.write().unwrap();
 294     /// *n = 2;
 295     ///
 296     /// assert!(lock.try_read().is_err());
 297     /// ```
 298     #[inline]
 299     #[stable(feature = "rust1", since = "1.0.0")]
 300     pub fn write(&self) -> LockResult<RwLockWriteGuard<'_, T>> {
 301         unsafe {
 302             self.inner.write();
 303             RwLockWriteGuard::new(self)
 304         }
 305     }
 306
 307     /// Attempts to lock this `RwLock` with exclusive write access.
 308     ///
 309     /// If the lock could not be acquired at this time, then `Err` is returned.
 310     /// Otherwise, an RAII guard is returned which will release the lock when
 311     /// it is dropped.
 312     ///
 313     /// This function does not block.
 314     ///
 315     /// This function does not provide any guarantees with respect to the ordering
 316     /// of whether contentious readers or writers will acquire the lock first.
 317     ///
 318     /// # Errors
 319     ///
 320     /// This function will return the [`Poisoned`] error if the `RwLock` is
 321     /// poisoned. An `RwLock` is poisoned whenever a writer panics while holding
 322     /// an exclusive lock. `Poisoned` will only be returned if the lock would
 323     /// have otherwise been acquired.
 324     ///
 325     /// This function will return the [`WouldBlock`] error if the `RwLock` could
 326     /// not be acquired because it was already locked exclusively.
 327     ///
 328     /// [`Poisoned`]: TryLockError::Poisoned
 329     /// [`WouldBlock`]: TryLockError::WouldBlock
 330     ///
 331     ///
 332     /// # Examples
 333     ///
 334     /// ```
 335     /// use std::sync::RwLock;
 336     ///
 337     /// let lock = RwLock::new(1);
 338     ///
 339     /// let n = lock.read().unwrap();
 340     /// assert_eq!(*n, 1);
 341     ///
 342     /// assert!(lock.try_write().is_err());
 343     /// ```
 344     #[inline]
 345     #[stable(feature = "rust1", since = "1.0.0")]
 346     pub fn try_write(&self) -> TryLockResult<RwLockWriteGuard<'_, T>> {
 347         unsafe {
 348             if self.inner.try_write() {
 349                 Ok(RwLockWriteGuard::new(self)?)
 350             } else {
 351                 Err(TryLockError::WouldBlock)
 352             }
 353         }
 354     }
 355
 356     /// Determines whether the lock is poisoned.
 357     ///
 358     /// If another thread is active, the lock can still become poisoned at any
 359     /// time. You should not trust a `false` value for program correctness
 360     /// without additional synchronization.
 361     ///
 362     /// # Examples
 363     ///
 364     /// ```
 365     /// use std::sync::{Arc, RwLock};
 366     /// use std::thread;
 367     ///
 368     /// let lock = Arc::new(RwLock::new(0));
 369     /// let c_lock = Arc::clone(&lock);
 370     ///
 371     /// let _ = thread::spawn(move || {
 372     ///     let _lock = c_lock.write().unwrap();
 373     ///     panic!(); // the lock gets poisoned
 374     /// }).join();
 375     /// assert_eq!(lock.is_poisoned(), true);
 376     /// ```
 377     #[inline]
 378     #[stable(feature = "sync_poison", since = "1.2.0")]
 379     pub fn is_poisoned(&self) -> bool {
 380         self.poison.get()
 381     }
 382
 383     /// Clear the poisoned state from a lock
 384     ///
 385     /// If the lock is poisoned, it will remain poisoned until this function is called. This allows
 386     /// recovering from a poisoned state and marking that it has recovered. For example, if the
 387     /// value is overwritten by a known-good value, then the mutex can be marked as un-poisoned. Or
 388     /// possibly, the value could be inspected to determine if it is in a consistent state, and if
 389     /// so the poison is removed.
 390     ///
 391     /// # Examples
 392     ///
 393     /// ```
 394     /// #![feature(mutex_unpoison)]
 395     ///
 396     /// use std::sync::{Arc, RwLock};
 397     /// use std::thread;
 398     ///
 399     /// let lock = Arc::new(RwLock::new(0));
 400     /// let c_lock = Arc::clone(&lock);
 401     ///
 402     /// let _ = thread::spawn(move || {
 403     ///     let _lock = c_lock.write().unwrap();
 404     ///     panic!(); // the mutex gets poisoned
 405     /// }).join();
 406     ///
 407     /// assert_eq!(lock.is_poisoned(), true);
 408     /// let guard = lock.write().unwrap_or_else(|mut e| {
 409     ///     **e.get_mut() = 1;
 410     ///     lock.clear_poison();
 411     ///     e.into_inner()
 412     /// });
 413     /// assert_eq!(lock.is_poisoned(), false);
 414     /// assert_eq!(*guard, 1);
 415     /// ```
 416     #[inline]
 417     #[unstable(feature = "mutex_unpoison", issue = "96469")]
 418     pub fn clear_poison(&self) {
 419         self.poison.clear();
 420     }
 421
 422     /// Consumes this `RwLock`, returning the underlying data.
 423     ///
 424     /// # Errors
 425     ///
 426     /// This function will return an error if the `RwLock` is poisoned. An
 427     /// `RwLock` is poisoned whenever a writer panics while holding an exclusive
 428     /// lock. An error will only be returned if the lock would have otherwise
 429     /// been acquired.
 430     ///
 431     /// # Examples
 432     ///
 433     /// ```
 434     /// use std::sync::RwLock;
 435     ///
 436     /// let lock = RwLock::new(String::new());
 437     /// {
 438     ///     let mut s = lock.write().unwrap();
 439     ///     *s = "modified".to_owned();
 440     /// }
 441     /// assert_eq!(lock.into_inner().unwrap(), "modified");
 442     /// ```
 443     #[stable(feature = "rwlock_into_inner", since = "1.6.0")]
 444     pub fn into_inner(self) -> LockResult<T>
 445     where
 446         T: Sized,
 447     {
 448         let data = self.data.into_inner();
 449         poison::map_result(self.poison.borrow(), |()| data)
 450     }
 451
 452     /// Returns a mutable reference to the underlying data.
 453     ///
 454     /// Since this call borrows the `RwLock` mutably, no actual locking needs to
 455     /// take place -- the mutable borrow statically guarantees no locks exist.
 456     ///
 457     /// # Errors
 458     ///
 459     /// This function will return an error if the `RwLock` is poisoned. An
 460     /// `RwLock` is poisoned whenever a writer panics while holding an exclusive
 461     /// lock. An error will only be returned if the lock would have otherwise
 462     /// been acquired.
 463     ///
 464     /// # Examples
 465     ///
 466     /// ```
 467     /// use std::sync::RwLock;
 468     ///
 469     /// let mut lock = RwLock::new(0);
 470     /// *lock.get_mut().unwrap() = 10;
 471     /// assert_eq!(*lock.read().unwrap(), 10);
 472     /// ```
 473     #[stable(feature = "rwlock_get_mut", since = "1.6.0")]
 474     pub fn get_mut(&mut self) -> LockResult<&mut T> {
 475         let data = self.data.get_mut();
 476         poison::map_result(self.poison.borrow(), |()| data)
 477     }
 478 }
 479
 480 #[stable(feature = "rust1", since = "1.0.0")]
 481 impl<T: ?Sized + fmt::Debug> fmt::Debug for RwLock<T> {
 482     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 483         let mut d = f.debug_struct("RwLock");
 484         match self.try_read() {
 485             Ok(guard) => {
 486                 d.field("data", &&*guard);
 487             }
 488             Err(TryLockError::Poisoned(err)) => {
 489                 d.field("data", &&**err.get_ref());
 490             }
 491             Err(TryLockError::WouldBlock) => {
 492                 struct LockedPlaceholder;
 493                 impl fmt::Debug for LockedPlaceholder {
 494                     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 495                         f.write_str("<locked>")
 496                     }
 497                 }
 498                 d.field("data", &LockedPlaceholder);
 499             }
 500         }
 501         d.field("poisoned", &self.poison.get());
 502         d.finish_non_exhaustive()
 503     }
 504 }
 505
 506 #[stable(feature = "rw_lock_default", since = "1.10.0")]
 507 impl<T: Default> Default for RwLock<T> {
 508     /// Creates a new `RwLock<T>`, with the `Default` value for T.
 509     fn default() -> RwLock<T> {
 510         RwLock::new(Default::default())
 511     }
 512 }
 513
 514 #[stable(feature = "rw_lock_from", since = "1.24.0")]
 515 impl<T> From<T> for RwLock<T> {
 516     /// Creates a new instance of an `RwLock<T>` which is unlocked.
 517     /// This is equivalent to [`RwLock::new`].
 518     fn from(t: T) -> Self {
 519         RwLock::new(t)
 520     }
 521 }
 522
 523 impl<'rwlock, T: ?Sized> RwLockReadGuard<'rwlock, T> {
 524     /// Create a new instance of `RwLockReadGuard<T>` from a `RwLock<T>`.
 525     // SAFETY: if and only if `lock.inner.read()` (or `lock.inner.try_read()`) has been
 526     // successfully called from the same thread before instantiating this object.
 527     unsafe fn new(lock: &'rwlock RwLock<T>) -> LockResult<RwLockReadGuard<'rwlock, T>> {
 528         poison::map_result(lock.poison.borrow(), |()| RwLockReadGuard {
 529             data: NonNull::new_unchecked(lock.data.get()),
 530             inner_lock: &lock.inner,
 531         })
 532     }
 533 }
 534
 535 impl<'rwlock, T: ?Sized> RwLockWriteGuard<'rwlock, T> {
 536     /// Create a new instance of `RwLockWriteGuard<T>` from a `RwLock<T>`.
 537     // SAFETY: if and only if `lock.inner.write()` (or `lock.inner.try_write()`) has been
 538     // successfully called from the same thread before instantiating this object.
 539     unsafe fn new(lock: &'rwlock RwLock<T>) -> LockResult<RwLockWriteGuard<'rwlock, T>> {
 540         poison::map_result(lock.poison.guard(), |guard| RwLockWriteGuard { lock, poison: guard })
 541     }
 542 }
 543
 544 #[stable(feature = "std_debug", since = "1.16.0")]
 545 impl<T: fmt::Debug> fmt::Debug for RwLockReadGuard<'_, T> {
 546     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 547         (**self).fmt(f)
 548     }
 549 }
 550
 551 #[stable(feature = "std_guard_impls", since = "1.20.0")]
 552 impl<T: ?Sized + fmt::Display> fmt::Display for RwLockReadGuard<'_, T> {
 553     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 554         (**self).fmt(f)
 555     }
 556 }
 557
 558 #[stable(feature = "std_debug", since = "1.16.0")]
 559 impl<T: fmt::Debug> fmt::Debug for RwLockWriteGuard<'_, T> {
 560     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 561         (**self).fmt(f)
 562     }
 563 }
 564
 565 #[stable(feature = "std_guard_impls", since = "1.20.0")]
 566 impl<T: ?Sized + fmt::Display> fmt::Display for RwLockWriteGuard<'_, T> {
 567     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 568         (**self).fmt(f)
 569     }
 570 }
 571
 572 #[stable(feature = "rust1", since = "1.0.0")]
 573 impl<T: ?Sized> Deref for RwLockReadGuard<'_, T> {
 574     type Target = T;
 575
 576     fn deref(&self) -> &T {
 577         // SAFETY: the conditions of `RwLockGuard::new` were satisfied when created.
 578         unsafe { self.data.as_ref() }
 579     }
 580 }
 581
 582 #[stable(feature = "rust1", since = "1.0.0")]
 583 impl<T: ?Sized> Deref for RwLockWriteGuard<'_, T> {
 584     type Target = T;
 585
 586     fn deref(&self) -> &T {
 587         // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when created.
 588         unsafe { &*self.lock.data.get() }
 589     }
 590 }
 591
 592 #[stable(feature = "rust1", since = "1.0.0")]
 593 impl<T: ?Sized> DerefMut for RwLockWriteGuard<'_, T> {
 594     fn deref_mut(&mut self) -> &mut T {
 595         // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when created.
 596         unsafe { &mut *self.lock.data.get() }
 597     }
 598 }
 599
 600 #[stable(feature = "rust1", since = "1.0.0")]
 601 impl<T: ?Sized> Drop for RwLockReadGuard<'_, T> {
 602     fn drop(&mut self) {
 603         // SAFETY: the conditions of `RwLockReadGuard::new` were satisfied when created.
 604         unsafe {
 605             self.inner_lock.read_unlock();
 606         }
 607     }
 608 }
 609
 610 #[stable(feature = "rust1", since = "1.0.0")]
 611 impl<T: ?Sized> Drop for RwLockWriteGuard<'_, T> {
 612     fn drop(&mut self) {
 613         self.lock.poison.done(&self.poison);
 614         // SAFETY: the conditions of `RwLockWriteGuard::new` were satisfied when created.
 615         unsafe {
 616             self.lock.inner.write_unlock();
 617         }
 618     }
 619 }