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

use crate::sys::rwlock as imp;

/// 基于操作系统的读写锁，用于静态变量。
///
/// 这个 rwlock 没有实现中毒。
///
/// 这个 rwlock 有一个 const 构造函数 ([`StaticRWLock::new`])，没有实现 `Drop` 来清理资源。
///
pub struct StaticRWLock(imp::RWLock);

impl StaticRWLock {
    /// 创建一个新的 rwlock 以供使用。
    pub const fn new() -> Self {
        Self(imp::RWLock::new())
    }

    /// 获取对基础锁的共享访问，从而阻止当前线程这样做。
    ///
    ///
    /// 当返回的守卫丢弃时，锁会自动解锁。
    #[inline]
    pub fn read(&'static self) -> StaticRWLockReadGuard {
        unsafe { self.0.read() };
        StaticRWLockReadGuard(&self.0)
    }

    /// 获取对基础锁的写访问权，从而阻止当前线程这样做。
    ///
    ///
    /// 当返回的守卫丢弃时，锁会自动解锁。
    #[inline]
    pub fn write(&'static self) -> StaticRWLockWriteGuard {
        unsafe { self.0.write() };
        StaticRWLockWriteGuard(&self.0)
    }
}

#[must_use]
pub struct StaticRWLockReadGuard(&'static imp::RWLock);

impl Drop for StaticRWLockReadGuard {
    #[inline]
    fn drop(&mut self) {
        unsafe {
            self.0.read_unlock();
        }
    }
}

#[must_use]
pub struct StaticRWLockWriteGuard(&'static imp::RWLock);

impl Drop for StaticRWLockWriteGuard {
    #[inline]
    fn drop(&mut self) {
        unsafe {
            self.0.write_unlock();
        }
    }
}

/// 基于 OS 的 reader-writer 锁。
///
/// 这个 rwlock 没有 const 构造函数，在它的 `Drop` 实现中清理它的资源并且可以安全地移动 (当没有被借用时)。
///
///
/// 这个 rwlock 没有实现中毒。
///
/// 这是 `Box<imp::RWLock>` 或 `imp::RWLock` 的包装器，具体取决于平台。
/// 在不能移动 `imp::RWLock` 的平台上，它是 boxed。
///
pub struct MovableRWLock(imp::MovableRWLock);

impl MovableRWLock {
    /// 创建一个新的 reader-writer 锁以供使用。
    pub fn new() -> Self {
        Self(imp::MovableRWLock::from(imp::RWLock::new()))
    }

    /// 获取对基础锁的共享访问，从而阻止当前线程这样做。
    ///
    #[inline]
    pub fn read(&self) {
        unsafe { self.0.read() }
    }

    /// 尝试获取对此锁的共享访问权，并返回是否成功。
    ///
    ///
    /// 此函数不会阻止当前线程。
    #[inline]
    pub fn try_read(&self) -> bool {
        unsafe { self.0.try_read() }
    }

    /// 获取对基础锁的写访问权，从而阻止当前线程这样做。
    ///
    #[inline]
    pub fn write(&self) {
        unsafe { self.0.write() }
    }

    /// 尝试获取对此锁的独占访问权，并返回是否成功。
    ///
    ///
    /// 此函数不会阻止当前线程。
    #[inline]
    pub fn try_write(&self) -> bool {
        unsafe { self.0.try_write() }
    }

    /// 解锁先前获取的对此锁的共享访问权限。
    ///
    /// 如果当前线程没有共享访问权限，则行为是不确定的。
    #[inline]
    pub unsafe fn read_unlock(&self) {
        self.0.read_unlock()
    }

    /// 解锁先前获得的对此锁的独占访问权。
    ///
    /// 如果当前线程当前没有独占访问权，则行为是不确定的。
    ///
    #[inline]
    pub unsafe fn write_unlock(&self) {
        self.0.write_unlock()
    }
}

impl Drop for MovableRWLock {
    fn drop(&mut self) {
        unsafe { self.0.destroy() };
    }
}