Rust / 系统课时
选择异步锁
选择异步锁
本节比较 std::sync 与 tokio::sync 的锁,重点判断锁等待是否会阻塞运行时线程、锁守卫是否需要跨越 .await。完成后,你能为短内存临界区和异步临界区选择合适的 Mutex 或 RwLock。
学习目标
- 根据临界区是否跨越
.await选择同步锁或异步锁 - 区分
Mutex与RwLock的适用条件和等待方式 - 避免持有
std::sync锁守卫进入异步挂起点
先判断锁的等待方式
std::sync::Mutex::lock 和 std::sync::RwLock::read/write 是同步阻塞调用;竞争激烈时,当前线程可能被挂起。tokio::sync 对应类型的加锁操作需要 .await,等待期间任务会让出运行时工作线程,因此更适合必须在异步上下文中等待锁的场景。
| 类型 | 获取方式 | 守卫跨 .await |
典型用途 |
|---|---|---|---|
std::sync::Mutex |
lock() |
不应跨越 | 很短的纯内存临界区 |
tokio::sync::Mutex |
lock().await |
可以跨越 | 临界区确实必须包含异步等待 |
std::sync::RwLock |
read()/write() |
不应跨越 | 短读写临界区且读并发有收益 |
tokio::sync::RwLock |
read().await/write().await |
可以跨越 | 异步读写临界区且读并发有收益 |
用一个程序验证两种持锁方式
下面程序先用 std::sync::Mutex 修改计数器,并通过词法作用域保证守卫在 .await 前释放;随后用 tokio::sync::Mutex 演示守卫可以合法跨越异步挂起点。示例中的 sleep 只用于展示语义,真实代码不应无理由延长持锁时间。
Cargo.toml 使用以下依赖:
[package]
name = "lock-choice"
version = "0.1.0"
edition = "2021"
[dependencies]
tokio = { version = "1", features = ["rt-multi-thread", "macros", "sync", "time"] }src/main.rs 内容如下:
use std::sync::{Arc, Mutex};
use tokio::sync::Mutex as AsyncMutex;
use tokio::time::{sleep, Duration};
#[tokio::main(flavor = "multi_thread", worker_threads = 2)]
async fn main() {
let counter = Arc::new(Mutex::new(0_u32));
let shared_counter = Arc::clone(&counter);
let first = tokio::spawn(async move {
{
// 同步锁只保护很短的内存修改,离开作用域后立即释放。
let mut guard = shared_counter.lock().unwrap();
*guard += 1;
}
tokio::task::yield_now().await;
});
first.await.unwrap();
println!("std counter = {}", *counter.lock().unwrap());
let async_counter = Arc::new(AsyncMutex::new(0_u32));
let shared_async_counter = Arc::clone(&async_counter);
let second = tokio::spawn(async move {
let mut guard = shared_async_counter.lock().await;
// Tokio 锁守卫允许跨 await,但这会延长其他任务的等待时间。
sleep(Duration::from_millis(10)).await;
*guard += 1;
});
second.await.unwrap();
println!("tokio counter = {}", *async_counter.lock().await);
}预期输出:
std counter = 1
tokio counter = 1运行 cargo run 后输出应稳定为两个 1。第一个任务在 yield_now().await 前已经离开同步锁作用域;第二个任务则持有 Tokio 锁守卫跨过 sleep(...).await,语义合法但会让同一把锁上的其他任务继续等待。
为什么不要让 std 守卫跨 await
异步任务在 .await 处可能暂停并让出执行权。如果此时仍持有标准库互斥锁,其他任务随后调用阻塞式 lock(),就可能占住运行时工作线程等待锁;线程数量有限时,这种组合还可能形成死锁。
在 tokio::spawn 等要求任务可在线程间移动的场景中,标准库锁守卫跨 .await 会使 Future 不满足 Send,直接导致编译失败。最稳妥的写法就是像主示例一样,用独立代码块缩短守卫的词法作用域,再进入异步等待点。
Tokio 的异步互斥锁解决的是“等待锁时不要阻塞运行时线程”,不是让临界区变成并行执行。守卫跨越越多 .await,串行化时间越长,因此即便使用 tokio::sync::Mutex,也应尽量缩短持锁范围。
Mutex 还是 RwLock
当所有访问都需要独占修改时,优先使用 Mutex。只有读操作明显多于写操作、读取可以真正并发,而且读临界区足够长到能抵消 RwLock 的管理成本时,RwLock 才可能更合适。
tokio::sync::RwLock 使用公平的写优先策略,避免读任务持续插队导致写任务长期饥饿;标准库 RwLock 的调度策略依赖操作系统实现,不能假设具有相同公平性。无论选择哪一种,是否使用 Tokio 版本仍然取决于锁等待和守卫跨度是否需要异步化。
如果共享状态只是计数器或标志位,可先考虑原子类型;如果共享的是需要顺序访问的连接、文件或协议状态,也可以让单个任务独占资源,再通过有界通道接收命令。能消除共享可变状态时,通常比在多个任务之间增加一把更复杂的锁更容易维护。