面试题：Rust中如何在结构体并发访问时控制可变性

使用Mutex：
- Mutex（互斥锁）是Rust标准库提供的一种同步原语，用于保护共享数据，防止多个线程同时访问。
- 示例代码如下：

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

struct MyStruct {
    data: i32,
}

fn main() {
    let shared_data = Arc::new(Mutex::new(MyStruct { data: 0 }));
    let mut handles = vec![];

    for _ in 0..10 {
        let data_clone = Arc::clone(&shared_data);
        let handle = thread::spawn(move || {
            let mut my_struct = data_clone.lock().unwrap();
            my_struct.data += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    let final_data = shared_data.lock().unwrap();
    println!("Final data: {}", final_data.data);
}

在上述代码中，Arc<Mutex<MyStruct>>被用于在多个线程间共享MyStruct。Mutex通过lock方法获取锁，只有获取到锁的线程才能访问和修改MyStruct的数据，从而避免数据竞争。

使用RwLock（读写锁）：
- 如果读操作远多于写操作，可以使用RwLock。它允许多个线程同时进行读操作，但只允许一个线程进行写操作。
- 示例代码如下：

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

struct MyStruct {
    data: i32,
}

fn main() {
    let shared_data = Arc::new(RwLock::new(MyStruct { data: 0 }));
    let mut handles = vec![];

    for _ in 0..5 {
        let data_clone = Arc::clone(&shared_data);
        let handle = thread::spawn(move || {
            let my_struct = data_clone.read().unwrap();
            println!("Read data: {}", my_struct.data);
        });
        handles.push(handle);
    }

    for _ in 0..2 {
        let data_clone = Arc::clone(&shared_data);
        let handle = thread::spawn(move || {
            let mut my_struct = data_clone.write().unwrap();
            my_struct.data += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    let final_data = shared_data.read().unwrap();
    println!("Final data: {}", final_data.data);
}

这里RwLock通过read方法获取读锁（允许多个线程同时读），通过write方法获取写锁（只允许一个线程写），以控制对MyStruct的访问，避免数据竞争。

星途面试题库

面试题：Rust中如何在结构体并发访问时控制可变性

知识考点

面试题答案