1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

#[cfg(all(test, not(target_os = "emscripten")))]
mod tests;

use crate::marker::PhantomPinned;
use crate::ops::Deref;
use crate::panic::{RefUnwindSafe, UnwindSafe};
use crate::pin::Pin;
use crate::sys::mutex as sys;

/// 可重入的相互排斥
///
/// 此互斥锁将阻止 *其他* 线程，等待该锁可用。
/// 已经锁定互斥锁的线程可以多次将其锁定而不会阻塞，从而避免了常见的死锁源。
///
pub struct ReentrantMutex<T> {
    inner: sys::ReentrantMutex,
    data: T,
    _pinned: PhantomPinned,
}

unsafe impl<T: Send> Send for ReentrantMutex<T> {}
unsafe impl<T: Send> Sync for ReentrantMutex<T> {}

impl<T> UnwindSafe for ReentrantMutex<T> {}
impl<T> RefUnwindSafe for ReentrantMutex<T> {}

/// 互斥锁的 "scoped lock" 的 RAII 实现。当此结构体被丢弃 (离开作用域) 时，这个锁将被解锁。
///
/// 可以通过此保护程序的 Deref 实现访问由互斥锁保护的数据。
///
/// # Mutability
///
/// 与 `MutexGuard` 不同，`ReentrantMutexGuard` 不实现 `DerefMut`，因为实现 trait 会违反 Rust 的引用别名规则。
/// 使用内部可变性 (通常为 `RefCell`) 以更改受保护的数据。
///
///
///
///
#[must_use = "if unused the ReentrantMutex will immediately unlock"]
pub struct ReentrantMutexGuard<'a, T: 'a> {
    lock: Pin<&'a ReentrantMutex<T>>,
}

impl<T> !Send for ReentrantMutexGuard<'_, T> {}

impl<T> ReentrantMutex<T> {
    /// 在解锁状态下创建一个新的可重入互斥锁。
    ///
    /// # Unsafety
    ///
    /// 该函数是不安全的，因为一旦此互斥锁处于其最终的静止位置，就要求调用 `init`，只有这样 lock/unlock 的方法才是安全的。
    ///
    ///
    pub const unsafe fn new(t: T) -> ReentrantMutex<T> {
        ReentrantMutex {
            inner: sys::ReentrantMutex::uninitialized(),
            data: t,
            _pinned: PhantomPinned,
        }
    }

    /// 初始化此互斥锁，以便可以使用。
    ///
    /// # Unsafety
    ///
    /// 多次调用是不安全的，必须在此之后调用，它将不再在内存中移动。
    ///
    pub unsafe fn init(self: Pin<&mut Self>) {
        self.get_unchecked_mut().inner.init()
    }

    /// 获取一个互斥锁，阻塞当前线程，直到能够这样做为止。
    ///
    /// 此函数将阻止调用方，直到可以获取互斥锁为止。
    /// 返回时，该线程是唯一具有互斥锁的线程。
    /// 当调用此方法的线程已持有锁时，调用将成功而不会阻塞。
    ///
    /// # Errors
    ///
    /// 如果此互斥锁的另一个用户在握住互斥锁时恐慌，那么如果以其他方式获取互斥锁，则此调用将返回失败。
    ///
    ///
    ///
    pub fn lock(self: Pin<&Self>) -> ReentrantMutexGuard<'_, T> {
        unsafe { self.inner.lock() }
        ReentrantMutexGuard { lock: self }
    }

    /// 尝试获取此锁。
    ///
    /// 如果此时无法获取锁，则返回 `Err`。
    /// 否则，将返回 RAII 守卫。
    ///
    /// 该函数不会阻止。
    ///
    /// # Errors
    ///
    /// 如果此互斥锁的另一个用户在握住互斥锁时恐慌，那么如果以其他方式获取互斥锁，则此调用将返回失败。
    ///
    ///
    pub fn try_lock(self: Pin<&Self>) -> Option<ReentrantMutexGuard<'_, T>> {
        if unsafe { self.inner.try_lock() } {
            Some(ReentrantMutexGuard { lock: self })
        } else {
            None
        }
    }
}

impl<T> Drop for ReentrantMutex<T> {
    fn drop(&mut self) {
        // 这实际上是安全的 b/c，我们知道此互斥锁没有进一步的用途 (由用户来安排丢弃互斥锁，这不是我们的工作)
        //
        //
        unsafe { self.inner.destroy() }
    }
}

impl<T> Deref for ReentrantMutexGuard<'_, T> {
    type Target = T;

    fn deref(&self) -> &T {
        &self.lock.data
    }
}

impl<T> Drop for ReentrantMutexGuard<'_, T> {
    #[inline]
    fn drop(&mut self) {
        unsafe {
            self.lock.inner.unlock();
        }
    }
}