Struct std::sync::RwLock 1.0.0[−][src]
pub struct RwLock<T: ?Sized> { /* fields omitted */ }Expand description
reader-writer 锁
这种类型的锁定在任何时间点都允许多个 readers 或最多一个 writer。 此锁的写入部分通常允许修改底层数据 (独占访问)，而此锁的读取部分通常允许进行只读访问 (共享访问)。
相比之下，Mutex 不会区分获取锁定的 readers 或 writers，因此会阻塞等待锁定变为可用的所有线程。
RwLock 将允许任意数量的 readers 获取锁，只要 writer 不持有该锁即可。
锁定的优先级策略取决于底层操作系统的实现，并且这种类型不能保证将使用任何特定的策略。
特别是，等待获取 write 中的锁的 writer 可能会也可能不会阻止对 read 的并发调用，例如：
潜在的死锁示例
// Thread 1 | // Thread 2
let _rg = lock.read(); |
| // 会阻塞
| let _wg = lock.write();
// 可能会死锁 |
let _rg = lock.read(); |类型参数 T 表示此锁保护的数据。
要求 T 满足 Send 在线程之间共享，并且 Sync 允许通过 readers 进行并发访问。
从锁定方法返回的 RAII 防护实现 Deref (对于 write 方法为 DerefMut) 以允许访问锁的内容。
Poisoning
RwLock 和 Mutex 一样，将在 panic 上中毒。
但是请注意，仅当 0panic 处于独占锁定状态 (写模式) 时，RwLock 才可能中毒。如果在任何 reader 中出现 panic，则锁不会中毒。
Examples
use std::sync::RwLock;
let lock = RwLock::new(5);
// 可以一次持有许多 reader 锁
{
let r1 = lock.read().unwrap();
let r2 = lock.read().unwrap();
assert_eq!(*r1, 5);
assert_eq!(*r2, 5);
} // 此时将丢弃读锁
// 只能持有一个写锁，但是
{
let mut w = lock.write().unwrap();
*w += 1;
assert_eq!(*w, 6);
} // 写锁在这里被丢弃Implementations
使用共享的读取访问权限锁定此 rwlock，阻塞当前线程，直到可以获取它为止。
调用线程将被阻塞，直到没有其他持有该锁的 writers 为止。 当此方法返回时，锁中可能当前存在其他 readers。 对于有争议的 readers 或 writers 将首先获取锁的顺序，此方法不提供任何保证。
返回 RAII 保护，一旦该线程被丢弃，它将释放该线程的共享访问。
Errors
如果 RwLock 中毒，则此函数将返回错误。当 writer panics 持有排他锁时，RwLock 会中毒。 获取锁定后，将立即发生故障。
Panics
如果当前线程已锁定，则调用此函数时可能为 panic。
Examples
use std::sync::{Arc, RwLock};
use std::thread;
let lock = Arc::new(RwLock::new(1));
let c_lock = Arc::clone(&lock);
let n = lock.read().unwrap();
assert_eq!(*n, 1);
thread::spawn(move || {
let r = c_lock.read();
assert!(r.is_ok());
}).join().unwrap();尝试使用共享的读取访问权限来获取此 rwlock。
如果此时不能授予访问权限，则返回 Err。
否则，将返回 RAII 保护，当该保护被丢弃时，该保护将释放共享访问。
该函数不会阻止。
对于有争议的 readers 或 writers 将首先获取锁的顺序，此函数不提供任何保证。
Errors
如果 RwLock 中毒，此函数将返回 Poisoned 错误。
当 writer panics 持有排他锁时，RwLock 会中毒。
Poisoned 只有在可以获取锁的情况下才会返回。
如果 RwLock 因为已经被独占锁定而无法获取，该函数将返回 WouldBlock 错误。
Examples
use std::sync::RwLock;
let lock = RwLock::new(1);
match lock.try_read() {
Ok(n) => assert_eq!(*n, 1),
Err(_) => unreachable!(),
};用独占式写访问锁定该 rwlock，阻塞当前线程，直到可以获取它为止。
当前其他 writers 或其他 readers 可以访问该锁时，此函数将不会返回。
返回一个 RAII 保护，当该保护被丢弃时，它将丢弃该读写锁的写访问。
Errors
如果 RwLock 中毒，则此函数将返回错误。 当 writer panics 持有排他锁时，RwLock 会中毒。 获取锁时将返回错误。
Panics
如果当前线程已锁定，则调用此函数时可能为 panic。
Examples
use std::sync::RwLock;
let lock = RwLock::new(1);
let mut n = lock.write().unwrap();
*n = 2;
assert!(lock.try_read().is_err());尝试使用互斥写访问权限锁定此 rwlock。
如果此时无法获取锁，则返回 Err。
否则，将返回 RAII 守卫，它将在锁被丢弃时释放锁。
该函数不会阻止。
对于有争议的 readers 或 writers 将首先获取锁的顺序，此函数不提供任何保证。
Errors
如果 RwLock 中毒，此函数将返回 Poisoned 错误。
当 writer panics 持有排他锁时，RwLock 会中毒。
Poisoned 只有在可以获取锁的情况下才会返回。
如果 RwLock 因为已经被独占锁定而无法获取，该函数将返回 WouldBlock 错误。
Examples
use std::sync::RwLock;
let lock = RwLock::new(1);
let n = lock.read().unwrap();
assert_eq!(*n, 1);
assert!(lock.try_write().is_err());确定锁是否中毒。
如果另一个线程处于活动状态，则锁定仍可能随时中毒。
如果没有其他同步，则不应信任 false 值来确保程序正确性。
Examples
use std::sync::{Arc, RwLock};
use std::thread;
let lock = Arc::new(RwLock::new(0));
let c_lock = Arc::clone(&lock);
let _ = thread::spawn(move || {
let _lock = c_lock.write().unwrap();
panic!(); // 锁被毒死了
}).join();
assert_eq!(lock.is_poisoned(), true);