面试题：Rust变量可变性在并发场景下的深度剖析

利用Arc和Mutex确保线程安全
- Arc（原子引用计数）：
  - Arc用于在多个线程间共享数据。它通过引用计数来管理数据的生命周期，允许多个线程持有对同一数据的引用。例如，假设有一个自定义的复杂数据结构ComplexStruct：

use std::sync::Arc;

struct SubStruct {
    value: i32
}

struct ComplexStruct {
    sub: SubStruct,
    // 其他嵌套子结构...
}

let shared_data = Arc::new(ComplexStruct {
    sub: SubStruct { value: 42 },
    // 初始化其他子结构...
});

Mutex（互斥锁）：
- Mutex用于控制对共享数据的访问。它提供了一种机制，保证在任何时刻只有一个线程可以访问共享数据，从而避免数据竞争。结合Arc，我们可以这样使用：

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

struct SubStruct {
    value: i32
}

struct ComplexStruct {
    sub: SubStruct,
    // 其他嵌套子结构...
}

let shared_data = Arc::new(Mutex::new(ComplexStruct {
    sub: SubStruct { value: 42 },
    // 初始化其他子结构...
}));

// 在不同线程中访问和修改数据
let handle = std::thread::spawn(move || {
    let mut data = shared_data.lock().unwrap();
    data.sub.value += 1;
});

线程安全访问流程：
- 首先，使用Arc将数据包装起来，使其可以在多个线程间共享。
- 然后，使用Mutex将Arc包裹的数据再进行包装，通过lock方法获取锁来访问内部数据。lock方法返回一个Result，如果获取锁成功，返回一个MutexGuard智能指针，该指针拥有对内部数据的可变引用。在作用域结束时，MutexGuard自动释放锁。

复杂场景下可变性相关的挑战及解决方案
- 挑战：
  - 嵌套结构的可变性：当共享变量是复杂的嵌套结构时，获取整个结构的可变引用可能会导致部分子结构在不需要全部修改时也被锁定。例如，ComplexStruct可能有多个子结构，而某个线程可能只需要修改其中一个子结构，但由于获取的是整个ComplexStruct的可变引用，其他子结构也被锁定，降低了并发性能。
  - 死锁：如果多个线程需要获取多个锁来访问和修改不同部分的共享数据，并且获取锁的顺序不一致，可能会导致死锁。比如线程A先获取锁1再获取锁2，而线程B先获取锁2再获取锁1，就可能发生死锁。
- 解决方案：
  - 细粒度锁：对于嵌套结构，可以为不同的子结构或部分数据使用不同的Mutex。这样，当某个线程只需要修改特定子结构时，只需要获取对应的Mutex，而不会影响其他部分的并发访问。例如：

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

struct SubStruct1 {
    value1: i32
}

struct SubStruct2 {
    value2: i32
}

struct ComplexStruct {
    sub1: Arc<Mutex<SubStruct1>>,
    sub2: Arc<Mutex<SubStruct2>>
}

let shared_data = ComplexStruct {
    sub1: Arc::new(Mutex::new(SubStruct1 { value1: 42 })),
    sub2: Arc::new(Mutex::new(SubStruct2 { value2: 100 }))
};

// 不同线程分别修改不同子结构
let handle1 = std::thread::spawn(move || {
    let mut sub1 = shared_data.sub1.lock().unwrap();
    sub1.value1 += 1;
});

let handle2 = std::thread::spawn(move || {
    let mut sub2 = shared_data.sub2.lock().unwrap();
    sub2.value2 -= 1;
});

 - **锁顺序一致**：为了避免死锁，在多个线程需要获取多个锁时，确保所有线程以相同的顺序获取锁。可以制定一个明确的锁获取顺序规则，并在代码中严格遵循。例如，定义一个枚举来表示锁的类型，并按照枚举值的顺序获取锁。

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

enum LockType {
    Lock1,
    Lock2
}

struct Resource1 {
    data: i32
}

struct Resource2 {
    data: i32
}

let resource1 = Arc::new(Mutex::new(Resource1 { data: 42 }));
let resource2 = Arc::new(Mutex::new(Resource2 { data: 100 }));

fn acquire_locks(locks: &[LockType], resource1: &Arc<Mutex<Resource1>>, resource2: &Arc<Mutex<Resource2>>) {
    for lock in locks {
        match lock {
            LockType::Lock1 => {
                let _guard = resource1.lock().unwrap();
                // 处理逻辑
            }
            LockType::Lock2 => {
                let _guard = resource2.lock().unwrap();
                // 处理逻辑
            }
        }
    }
}

// 所有线程按相同顺序获取锁
let handle1 = std::thread::spawn(move || {
    acquire_locks(&[LockType::Lock1, LockType::Lock2], &resource1, &resource2);
});

let handle2 = std::thread::spawn(move || {
    acquire_locks(&[LockType::Lock1, LockType::Lock2], &resource1, &resource2);
});

星途面试题库

面试题：Rust变量可变性在并发场景下的深度剖析

知识考点

面试题答案