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 使用以下依赖:

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 内容如下:

rust
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);
}

预期输出:

text
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 版本仍然取决于锁等待和守卫跨度是否需要异步化。

如果共享状态只是计数器或标志位,可先考虑原子类型;如果共享的是需要顺序访问的连接、文件或协议状态,也可以让单个任务独占资源,再通过有界通道接收命令。能消除共享可变状态时,通常比在多个任务之间增加一把更复杂的锁更容易维护。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

选择异步锁

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通