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); } // 写锁在这里被丢弃Run
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();Run
尝试使用共享的读取访问权限来获取此 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!(), };Run
用独占式写访问锁定该 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());Run
尝试使用互斥写访问权限锁定此 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());Run
确定锁是否中毒。
如果另一个线程处于活动状态，则锁定仍可能随时中毒。
如果没有其他同步，则不应信任 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);Run