面试题：Rust借用检查器在并发场景下对所有权转移的处理

确保线程安全的方法

使用 Mutex 或 RwLock：
- Mutex（互斥锁）：
  - Mutex 用于保护共享资源，通过提供 lock 方法来获取锁。当一个线程调用 lock 时，如果锁可用，它会获得锁并可以访问和修改 Resource。如果锁不可用，线程会被阻塞，直到锁被释放。
  - 示例代码：

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

struct Resource {
    data: i32
}

fn main() {
    let shared_resource = Arc::new(Mutex::new(Resource { data: 0 }));
    let mut handles = vec![];
    for _ in 0..10 {
        let resource_clone = shared_resource.clone();
        let handle = thread::spawn(move || {
            let mut resource = resource_clone.lock().unwrap();
            resource.data += 1;
        });
        handles.push(handle);
    }
    for handle in handles {
        handle.join().unwrap();
    }
    let result = shared_resource.lock().unwrap().data;
    println!("Final result: {}", result);
}

RwLock（读写锁）：
- 当读操作远多于写操作时，RwLock 更合适。多个线程可以同时获取读锁来读取 Resource，但只有一个线程可以获取写锁来修改它。
- 示例代码：

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

struct Resource {
    data: i32
}

fn main() {
    let shared_resource = Arc::new(RwLock::new(Resource { data: 0 }));
    let mut handles = vec![];
    for _ in 0..10 {
        let resource_clone = shared_resource.clone();
        let handle = thread::spawn(move || {
            let resource = resource_clone.read().unwrap();
            println!("Read data: {}", resource.data);
        });
        handles.push(handle);
    }
    for handle in handles {
        handle.join().unwrap();
    }
    let mut resource = shared_resource.write().unwrap();
    resource.data = 42;
    println!("Set data to 42");
}

Arc（原子引用计数）与 Mutex 或 RwLock 结合：
- Arc 用于在多个线程间共享数据的所有权。它允许在堆上分配的数据被多个线程引用，并且其引用计数是原子的，保证了线程安全。结合 Mutex 或 RwLock，可以实现线程安全的共享可变数据。

Rust 借用检查器在并发场景下的工作方式

静态检查：
- Rust 的借用检查器在编译时工作，它确保在任何给定时间，对资源的引用遵循借用规则。在并发场景中，它会检查锁的获取和释放是否正确，以及对共享资源的访问是否符合独占访问（写操作）或共享访问（读操作）的规则。
- 例如，在上面的 Mutex 示例中，借用检查器确保只有在获取 lock 后才能访问 Resource，并且在锁未释放时不会有其他线程同时访问。
作用域检查：
- 借用检查器会检查引用的作用域。当一个线程获取锁并访问共享资源时，该资源的引用在锁的作用域内有效。一旦锁被释放，引用就会失效，防止了悬空引用的产生。

处理所有权转移时面临的挑战及解决方法

挑战：
- 所有权转移与并发：在多线程环境中，所有权转移需要保证线程安全。例如，当一个线程将 Resource 的所有权转移给另一个线程时，需要确保在转移过程中没有其他线程访问该资源，否则可能导致数据竞争。
- 死锁风险：如果多个线程以不同顺序获取锁，可能会导致死锁。例如，线程 A 持有锁 L1 并试图获取锁 L2，而线程 B 持有锁 L2 并试图获取锁 L1。
解决方法：
- 所有权转移：通过 Mutex 或 RwLock 保护资源，在转移所有权时，先获取锁，然后进行所有权转移操作。例如，可以将 Resource 封装在 Mutex 中，在转移所有权时，获取 Mutex 的锁，然后将 Resource 从一个线程传递到另一个线程。
- 死锁避免：
  - 锁顺序一致：确保所有线程以相同顺序获取锁，这样可以避免死锁。例如，如果有多个锁 L1、L2、L3，所有线程都先获取 L1，再获取 L2，最后获取 L3。
  - 使用 try_lock：Mutex 和 RwLock 都提供 try_lock 方法，该方法尝试获取锁，如果锁不可用，立即返回 Err。线程可以根据 try_lock 的返回结果来决定是否继续等待或采取其他措施，从而避免死锁。

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

struct Resource {
    data: i32
}

fn main() {
    let shared_resource = Arc::new(Mutex::new(Resource { data: 0 }));
    let mut handles = vec![];
    for _ in 0..10 {
        let resource_clone = shared_resource.clone();
        let handle = thread::spawn(move || {
            match resource_clone.try_lock() {
                Ok(mut resource) => {
                    resource.data += 1;
                }
                Err(_) => {
                    println!("Could not acquire lock");
                }
            }
        });
        handles.push(handle);
    }
    for handle in handles {
        handle.join().unwrap();
    }
    let result = shared_resource.lock().unwrap().data;
    println!("Final result: {}", result);
}

星途面试题库

面试题：Rust借用检查器在并发场景下对所有权转移的处理

知识考点

面试题答案

确保线程安全的方法

Rust 借用检查器在并发场景下的工作方式

处理所有权转移时面临的挑战及解决方法