Rust 并发加速器：用 Condvar 实现线程间“精确握手”与高效等待

在开发高性能并发应用时，线程间常常需要等待某个特定事件的发生，而不是盲目地消耗 CPU 资源进行忙等（Busy-Waiting）。Rust 提供了 条件变量（Condition Variable, Condvar），这是一种高级同步原语，它总是与 互斥锁（Mutex） 结合使用，共同构建出高效的线程“精确握手”机制。

我们将通过一个实际的例子，展示如何利用 Arc<Mutex<T>, Condvar> 结构，实现一个经典的启动同步模式：确保主线程只有在子线程完成初始化操作后才能继续运行。您将看到 cvar.wait() 如何优雅地释放锁并休眠，实现零 CPU 消耗的等待。

Rust 多线程 - Condvar 条件变量

Conditional Variable 条件变量

Condvar

• 条件变量 Condition Variable：提供在等待事件发生时阻塞线程的能力
• Condvar 表示能够阻塞一个线程的能力，使其在等待事件发生时不消耗 CPU 时间
• 条件变量通常与一个 bool 谓词（predicate，一个条件）和一个 mutex 关联。在决定线程必须阻塞之前，谓词总是在 mutex 内部被验证。
• 注意：任何试图在同一个 CondVar 上使用多个 mutex 的操作，可能会导致运行时的 panic。

实操

创建项目

cargo new condvar
cd condvar
ls

main.rs 文件

use std::{
    sync::{Arc, Condvar, Mutex},
    thread,
};

fn main() {
    let pair = Arc::new((Mutex::new(false), Condvar::new()));
    let pair2 = Arc::clone(&pair);
    thread::spawn(move || {
        // let &(ref lock, ref cvar) = &*pair2;
        let (lock, cvar) = &*pair2;
        let mut started = lock.lock().unwrap();
        *started = true;
        cvar.notify_one();
    });

    // let &(ref lock, ref cvar) = &*pair;
    let (lock, cvar) = &*pair;
    let mut started = lock.lock().unwrap();
    while !*started {
        started = cvar.wait(started).unwrap();
    }

    println!("Hello, world!");
}

这段 Rust 代码是线程间同步启动和通信的经典示例，它使用了 Mutex（互斥锁） 和 Condvar（条件变量） 这两种核心同步原语。为了在主线程和新创建的子线程之间安全地共享这些同步对象，它们被包裹在 Arc（原子引用计数） 智能指针内。子线程（信号发送者）启动后，首先获取 Mutex 保护下的共享状态 started，将其置为 true，然后调用 cvar.notify_one() 发出唤醒信号。与此同时，主线程（等待者）同样获取 Mutex，检查 started 状态；如果条件仍为 false，它会调用 cvar.wait()，这一关键操作将原子性地释放互斥锁并阻塞当前线程，从而高效地等待信号而不浪费 CPU。一旦被子线程唤醒，wait 操作会重新获取互斥锁，让主线程再次检查条件并退出等待循环，成功实现了子线程启动后向主线程发送的精确握手和启动同步。

运行

➜ cargo run
   Compiling condvar v0.1.0 (/Users/qiaopengjun/Code/Rust/RustJourney/condvar)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.19s
     Running `target/debug/condvar`
Hello, world!

这段简洁的输出 Hello, world! 是 Mutex 和 Condvar 同步机制成功协作的完美证明。

运行输出 (Output) 解释

这个结果表明子线程和主线程之间实现了一个高效、非忙等（Non-Busy Waiting）的握手协议：

1. 子线程 (Sender) 成功启动并发送信号：
   • 子线程启动，迅速获取了 Mutex 锁。
   • 它将共享状态 started 从 false 改为 true。
   • 它调用 cvar.notify_one() 唤醒了正在等待的线程。
2. 主线程 (Waiter) 成功等待并接收信号：
   • 主线程进入 while !*started 循环，发现 started 仍为 false（在子线程修改之前）。
   • 主线程调用 cvar.wait(started).unwrap()。
   • 关键点： wait() 操作原子性地完成了两件事：它释放了主线程对 Mutex 的持有，并将主线程置于休眠状态。
   • 当子线程发出 notify_one() 信号后，主线程被唤醒。
   • 主线程从 wait() 返回前，会自动重新获取 Mutex 锁。
   • 主线程再次检查条件 !*started，发现它已经被子线程设置为 true，循环条件不成立，成功退出循环。

最终结果： 主线程在确认子线程完成其启动任务后才继续执行并打印出 Hello, world!。整个过程避免了像 thread::sleep() 那样的不确定等待，确保了线程间的执行顺序和数据同步的正确性。

总结

通过本次对 Condvar 的实操，我们掌握了 Rust 中最优雅的线程同步模式。其核心价值在于 cvar.wait() 的原子操作：它在释放互斥锁和阻塞线程之间没有时间间隙，完美解决了可能导致信号丢失的竞态条件。

我们使用的 *`while !started循环模式（Spurious Wakeup Guard）** 也至关重要，它保证了即使线程被“虚假唤醒”也能再次检查条件，避免错误执行。理解并运用Arc提供的**安全共享**、Mutex提供的**数据独占**以及Condvar` 提供的高效等待，是构建任何复杂、高可靠性 Rust 并发系统的必备技能。

参考

• Rust 程序设计语言： https://kaisery.github.io/trpl-zh-cn/
• 通过例子学 Rust： https://rustwiki.org/zh-CN/rust-by-example/
• Rust 语言圣经： https://course.rs/about-book.html
• Rust 秘典： https://nomicon.purewhite.io/intro.html
• Rust 算法教程： https://algo.course.rs/about-book.html
• Rust 参考手册： https://rustwiki.org/zh-CN/reference/introduction.html