Rust 并发同步：Mutex 与 RwLock 智能指针

文章目录

[Rust 并发同步：Mutex 与 RwLock 智能指针](#Rust 并发同步：Mutex 与 RwLock 智能指针)
- Mutex：独占访问的基础同步原语
- RwLock：读多写少场景优化方案
- [Mutex 与 RwLock 对比](#Mutex 与 RwLock 对比)
- 总结

Rust 并发同步：Mutex 与 RwLock 智能指针

在 Rust 并发编程中，所有权与借用规则从编译期规避了大部分数据竞争，但当需要在多线程间共享可变状态时，仅靠基础规则远远不够。此时，同步原语便成为关键工具，其中，Mutex（互斥锁）和 RwLock（读写锁）是标准库中最常用的两个同步智能指针，它们既能保证线程安全，又能通过内部可变性突破 Rust 的借用限制。本文将从原理、用法到注意事项，帮你彻底掌握这两个工具的使用方法。

Mutex：独占访问的基础同步原语

Mutex（Mutual Exclusion，互斥锁）的核心作用是保证"同一时间只有一个线程能访问被保护的数据"，是并发编程中最基础、最通用的同步手段。它与 Arc（原子引用计数）搭配使用，可实现多线程间的所有权共享与保障数据一致性。

核心特性

互斥性 ：线程必须先通过 lock()方法获取锁才能访问内部数据；若锁已被其他线程持有，当前线程会阻塞，直到锁被释放。这种独占性从根本上避免了多线程同时修改数据的风险。
内部可变性 ：与 RefCell 类似，Mutex 本身是不可变的，但通过 lock() 方法可获取内部数据的可变引用（MutexGuard<T>），实现"外部不可变、内部可变"的特性。
Poisoning（中毒机制） ：若持有锁的线程意外 panic，比如未正常释放锁，Mutex 会标记为"中毒"状态。后续线程调用 lock() 时，会返回错误，避免访问被 panic 破坏的不一致数据。

实战用法：多线程计数器

最典型的场景是多线程对同一个计数器进行累加，通过 Mutex 保证每次累加操作的原子性，结合 Arc 实现多线程共享所有权：

rust 复制代码

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

fn main() {
    // 用 Arc 包裹 Mutex，实现多线程所有权共享
    let counter = Arc::new(Mutex::new(0));
    let mut handles = Vec::new();

    // 启动10个线程，每个线程对计数器执行+1操作
    for _ in 0..10 {
        // Arc 克隆，仅增加引用计数，不复制数据
        let counter_clone = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            // 获取锁：阻塞直到锁可用，unwrap 临时处理错误
            let mut num = counter_clone.lock().unwrap();
            // 修改内部数据（MutexGuard 自动实现 Deref，可直接解引用操作）
            *num += 1;
            // 作用域结束，MutexGuard 自动 drop，无需手动解锁
        });
        handles.push(handle);
    }

    // 等待所有线程执行完毕，避免主线程提前退出
    for handle in handles {
        handle.join().unwrap();
    }

    // 最终结果：10（保证多线程累加的正确性）
    println!("多线程累加结果：{}", *counter.lock().unwrap());
}

注意事项

避免死锁：死锁的核心诱因是"线程持有锁时，再次请求自身或其他线程持有的锁"。例如，线程A持有锁1，请求锁2；线程B持有锁2，请求锁1，便会陷入无限等待。规避方法：统一锁的获取顺序，避免在锁的作用域内调用可能获取其他锁的函数。
Poisoning的正确处理 ：实战中不应直接用 unwrap() 忽略 lock() 的错误，需用 match 或 if let 处理中毒情况。
锁的作用域要最小化：获取锁后，应尽快完成数据操作并释放锁，避免长时间占用锁导致其他线程阻塞，降低并发效率。

RwLock：读多写少场景优化方案

RwLock（Read-Write Lock，读写锁）是 Mutex 的优化版，它基于"读共享、写独占"的原则，解决了 Mutex 无论读写都独占锁的性能瓶颈。在读操作远多于写操作 的场景（如缓存查询、配置读取），RwLock 能显著提升并发效率。

核心特性

双锁机制 ：RwLock 提供两种锁：读锁（read()）和写锁（write()）。读锁可被多个线程同时获取（共享访问），写锁仅能被一个线程获取（独占访问）；读锁与写锁互斥（读锁持有期间，写锁无法获取；写锁持有期间，读锁无法获取）。
性能优势 ：读操作无需互斥，多个线程可同时读取数据，避免了 Mutex 中"读操作也需排队"的浪费；仅在写操作时才会独占锁，兼顾安全性与并发效率。
同 Mutex 的共性：支持内部可变性、Poisoning 机制，需与 Arc 搭配实现多线程共享，RwLockReadGuard 和 RwLockWriteGuard 会自动释放锁。

实战用法：读写分离的缓存模拟

模拟一个简单的缓存系统：多个读线程查询缓存，单个写线程更新缓存，用 RwLock 实现读写分离，提升查询效率：

rust 复制代码

use std::sync::{Arc, RwLock};
use std::thread;
use std::time::Duration;

fn main() {
    // 用 Arc 包裹 RwLock，存储缓存数据
    let cache = Arc::new(RwLock::new(vec![
        ("rust".to_string(), 100),
        ("mutex".to_string(), 200),
    ]));
    let mut handles = Vec::new();

    // 启动5个读线程，可同时获取读锁，并行查询
    for i in 0..5 {
        let cache_clone = Arc::clone(&cache);
        let handle = thread::spawn(move || {
            // 获取读锁，共享访问缓存
            let cache_data = cache_clone.read().unwrap();
            // 模拟查询操作
            let value = cache_data
                .iter()
                .find(|(k, _)| k == &"rust")
                .map(|(_, v)| *v)
                .unwrap();
            println!("读线程{}: 查询到rust的值为{}", i, value);
            // 模拟读操作耗时
            thread::sleep(Duration::from_millis(100));
        });
        handles.push(handle);
    }

    // 启动1个写线程，独占写锁，更新缓存
    let cache_clone = Arc::clone(&cache);
    let write_handle = thread::spawn(move || {
        // 获取写锁：会阻塞，直到所有读锁释放
        let mut cache_data = cache_clone.write().unwrap();
        // 模拟更新缓存
        cache_data.push(("rwlock".to_string(), 300));
        println!("写线程：缓存更新完成，新增键值对(rwlock, 300)");
        // 模拟写操作耗时
        thread::sleep(Duration::from_millis(200));
    });
    handles.push(write_handle);

    // 等待所有线程执行完毕
    for handle in handles {
        handle.join().unwrap();
    }

    // 验证缓存更新结果
    let final_cache = cache.read().unwrap();
    println!("最终缓存内容：{:?}", final_cache);
}

注意事项

写饥饿问题 ：Rust标准库的 RwLock 未实现写线程优先级，若读线程持续不断地获取读锁，写线程可能长时间无法获取写锁（陷入"饥饿"）。解决方案：可使用第三方库，如 parking_lot，的RwLock，它支持写优先级配置；或在写操作频繁的场景，改用 Mutex。
禁止锁升级：切勿在持有读锁的同时尝试获取写锁（即"锁升级"），这会导致死锁，即读锁未释放，写锁无法获取；而当前线程持有读锁，又会阻塞其他线程释放读锁，形成无限等待。
读锁的开销 ：RwLock 的读锁需要维护"读线程计数"，其开销略高于 Mutex 的锁操作。因此，若读操作并不频繁（读写频率接近），使用 Mutex 反而更高效。

Mutex 与 RwLock 对比

特性	Mutex（互斥锁）	RwLock（读写锁）
访问模式	独占访问（无论读写，同一时间仅一个线程）	共享读、独占写（多线程可同时读，单线程可写）
性能开销	低（仅需简单的互斥判断，无额外计数操作）	中（读锁需维护读线程计数，写锁需等待所有读锁释放）
适用场景	1. 读写频率相近；2. 写操作频繁；3. 简单并发场景（无需读写分离）	1. 读多写少（读操作占比80%以上）；2. 读操作耗时较长（如缓存查询、文件读取）
潜在问题	读操作排队，并发效率低（读多写少场景）	写饥饿、锁升级死锁、读锁计数开销

简单的来说：读多写少用 RwLock，读写均衡或写多用 Mutex；若追求更简洁的代码，且并发压力不大，Mutex 是更稳妥的选择，避免 RwLock 的潜在问题。

总结

Mutex 和 RwLock 是 Rust 并发编程中"共享可变状态"的核心工具，它们的本质是通过"锁机制"配合 Arc 的引用计数，实现多线程间的安全数据共享，同时借助 Rust 的类型系统，在编译期规避数据竞争。后续可尝试用这两个工具实现更复杂的并发场景，例如：线程池中的任务队列（Mutex）、全局配置管理（RwLock），通过实战加深对锁机制的理解。