面试题：Rust向量元素访问安全保障与并发

使用Mutex实现多线程安全访问向量：
- 机制：Mutex（互斥锁）是一种同步原语，它通过允许同一时间只有一个线程能够获取锁来访问共享资源，从而保障资源访问的安全性。当一个线程获取了Mutex的锁后，其他线程需要等待该锁被释放才能获取并访问共享资源。对于向量元素的访问和修改，由于Mutex确保同一时间只有一个线程能操作向量，所以能保证向量元素访问的安全。
- 代码示例：

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

fn main() {
    let shared_vec = Arc::new(Mutex::new(vec![1, 2, 3]));
    let mut handles = vec![];

    for _ in 0..3 {
        let clone = Arc::clone(&shared_vec);
        let handle = thread::spawn(move || {
            let mut data = clone.lock().unwrap();
            for i in 0..data.len() {
                data[i] += 1;
            }
        });
        handles.push(handle);
    }

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

    let result = shared_vec.lock().unwrap();
    println!("{:?}", result);
}

使用RwLock实现多线程安全访问向量（适用于读多写少场景）：
- 机制：RwLock（读写锁）允许多个线程同时进行读操作，因为读操作不会修改共享资源，所以不会产生数据竞争。但是，当有线程进行写操作时，需要独占锁，其他读线程和写线程都需要等待写操作完成并释放锁。对于向量，如果读操作频繁，写操作较少，使用RwLock可以提高并发效率，同时通过写锁的独占机制保障向量元素在写操作时的安全。
- 代码示例：

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

fn main() {
    let shared_vec = Arc::new(RwLock::new(vec![1, 2, 3]));
    let mut handles = vec![];

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

    let write_clone = Arc::clone(&shared_vec);
    let write_handle = thread::spawn(move || {
        let mut data = write_clone.write().unwrap();
        for i in 0..data.len() {
            data[i] += 1;
        }
    });

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

    let result = shared_vec.read().unwrap();
    println!("Final data: {:?}", result);
}

面试题：Rust向量元素访问安全保障与并发

知识考点

面试题答案