面试题：Rust非作用域互斥体在复杂场景下的线程安全问题

可能出现的线程安全问题

死锁：多个线程可能互相等待对方释放锁，例如线程A持有锁1并等待锁2，而线程B持有锁2并等待锁1。
数据竞争：由于非作用域互斥体可能被不正确地使用，导致多个线程同时访问共享资源，尤其是在复杂读写操作过程中，可能出现数据不一致。
条件竞争：在线程间存在数据依赖的情况下，可能因为线程调度时机的不同，导致数据依赖关系被破坏。

Rust解决方法

使用std::sync::Mutex和Rc/Arc：
- Mutex提供了线程安全的互斥锁机制。通过Mutex::lock()方法获取锁，该方法返回一个MutexGuard，它在作用域结束时自动释放锁，避免手动管理锁的释放，从而防止死锁。
- 对于需要在多个线程间共享的数据，使用Arc（原子引用计数）来管理其生命周期。例如：

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

let shared_data = Arc::new(Mutex::new(vec![1, 2, 3]));
let data_clone = shared_data.clone();
std::thread::spawn(move || {
    let mut data = data_clone.lock().unwrap();
    data.push(4);
});

使用std::sync::Condvar处理数据依赖：
- Condvar（条件变量）用于线程间的同步，当某个条件满足时，唤醒等待的线程。例如，线程A需要等待线程B完成某个操作后才能继续，线程B完成操作后通过Condvar唤醒线程A。

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

let data = Arc::new((Mutex::new(false), Condvar::new()));
let data_clone = data.clone();

let handle1 = std::thread::spawn(move || {
    let (lock, cvar) = &*data_clone;
    let mut ready = lock.lock().unwrap();
    while!*ready {
        ready = cvar.wait(ready).unwrap();
    }
    println!("Thread 1: Data is ready");
});

let handle2 = std::thread::spawn(move || {
    let (lock, _) = &*data;
    let mut ready = lock.lock().unwrap();
    *ready = true;
    drop(ready);
    println!("Thread 2: Setting data as ready");
});

使用std::sync::RwLock处理读写操作：
- RwLock允许多个线程同时进行读操作，但只允许一个线程进行写操作。这对于复杂读写操作场景很有用，提高了读操作的并发性能。

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

let shared_data = Arc::new(RwLock::new(vec![1, 2, 3]));
let data_clone = shared_data.clone();
std::thread::spawn(move || {
    let data = data_clone.read().unwrap();
    println!("Read data: {:?}", data);
});

let data_clone = shared_data.clone();
std::thread::spawn(move || {
    let mut data = data_clone.write().unwrap();
    data.push(4);
});

星途面试题库

面试题：Rust非作用域互斥体在复杂场景下的线程安全问题

知识考点

面试题答案

可能出现的线程安全问题

Rust解决方法