面试题：Rust中Mutex与RwLock在读写场景下的性能差异

Mutex性能特点

读写性能：Mutex（互斥锁）在多线程环境下，同一时间只允许一个线程访问被保护的数据。无论是读操作还是写操作，都需要获取锁。这意味着如果有大量的读操作，每个读操作都要竞争锁，会导致性能瓶颈，因为读操作本身是线程安全的，多个读操作同时进行并不会产生数据竞争问题，但Mutex限制了这种并发。
适用场景：当读写操作频率相近，或者写操作较多时，Mutex是比较合适的选择。因为每次写操作都需要独占访问以保证数据一致性，而Mutex能很好地满足这种需求。

RwLock性能特点

读写性能：RwLock（读写锁）允许多个线程同时进行读操作，因为读操作不会修改数据，不会产生数据竞争。只有在进行写操作时，才需要独占访问，此时会阻止其他任何读写操作。这在有大量读操作和少量写操作的场景下，能显著提高性能，因为读操作可以并发执行，减少了等待锁的时间。
适用场景：当读操作远远多于写操作时，优先选择RwLock。例如在一个数据库查询系统中，大部分操作是读取数据，只有偶尔的更新操作，这种场景下RwLock能充分发挥其优势，提高系统整体性能。

举例

优先选择Mutex的场景：假设我们有一个银行账户类，其中有存款和取款操作（写操作），同时也有查询余额操作（读操作）。由于存款和取款操作需要保证数据一致性，而且这些操作频率可能与查询余额的频率相近或者写操作更频繁。在这种情况下，使用Mutex更合适。例如：

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

struct BankAccount {
    balance: i32,
}

impl BankAccount {
    fn new(initial_balance: i32) -> Self {
        BankAccount { balance: initial_balance }
    }

    fn deposit(&mut self, amount: i32) {
        self.balance += amount;
    }

    fn withdraw(&mut self, amount: i32) -> bool {
        if self.balance >= amount {
            self.balance -= amount;
            true
        } else {
            false
        }
    }

    fn get_balance(&self) -> i32 {
        self.balance
    }
}

fn main() {
    let account = Arc::new(Mutex::new(BankAccount::new(100)));
    let handle1 = {
        let account = account.clone();
        std::thread::spawn(move || {
            let mut account = account.lock().unwrap();
            account.deposit(50);
        })
    };
    let handle2 = {
        let account = account.clone();
        std::thread::spawn(move || {
            let mut account = account.lock().unwrap();
            account.withdraw(30);
        })
    };
    let handle3 = {
        let account = account.clone();
        std::thread::spawn(move || {
            let account = account.lock().unwrap();
            println!("Balance: {}", account.get_balance());
        })
    };
    handle1.join().unwrap();
    handle2.join().unwrap();
    handle3.join().unwrap();
}

优先选择RwLock的场景：假设我们有一个配置文件读取系统，配置文件会被多个线程频繁读取，但很少更新。例如：

use std::sync::{Arc, RwLock};

struct Config {
    setting1: String,
    setting2: i32,
}

impl Config {
    fn new() -> Self {
        Config {
            setting1: "default_value".to_string(),
            setting2: 42,
        }
    }

    fn get_setting1(&self) -> &str {
        &self.setting1
    }

    fn get_setting2(&self) -> i32 {
        self.setting2
    }

    fn update_setting1(&mut self, new_value: String) {
        self.setting1 = new_value;
    }

    fn update_setting2(&mut self, new_value: i32) {
        self.setting2 = new_value;
    }
}

fn main() {
    let config = Arc::new(RwLock::new(Config::new()));
    let read_handles: Vec<_> = (0..10).map(|_| {
        let config = config.clone();
        std::thread::spawn(move || {
            let config = config.read().unwrap();
            println!("Setting1: {}, Setting2: {}", config.get_setting1(), config.get_setting2());
        })
    }).collect();
    let write_handle = {
        let config = config.clone();
        std::thread::spawn(move || {
            let mut config = config.write().unwrap();
            config.update_setting1("new_value".to_string());
        })
    };
    for handle in read_handles {
        handle.join().unwrap();
    }
    write_handle.join().unwrap();
}

在这个例子中，读操作可以并发执行，而写操作会独占锁，符合读多写少的场景特点。

面试题：Rust中Mutex与RwLock在读写场景下的性能差异

知识考点

面试题答案

Mutex性能特点

RwLock性能特点

举例