面试题：Rust多线程并发编程中的死锁预防及排查

死锁产生的原因

资源竞争：多个线程同时竞争有限的资源，如锁、文件句柄等。如果线程获取资源的顺序不一致，就可能导致死锁。例如，线程A获取锁1后尝试获取锁2，而线程B获取锁2后尝试获取锁1，双方都不释放已持有的锁，就会造成死锁。
循环依赖：多个线程之间形成了资源依赖的循环链。例如，线程A依赖线程B释放的资源，线程B依赖线程C释放的资源，而线程C又依赖线程A释放的资源，形成循环，导致死锁。

预防死锁的方法

按照固定顺序获取锁：在Rust中，当需要获取多个锁时，所有线程都按照相同的顺序获取锁。例如：

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

fn main() {
    let lock1 = Arc::new(Mutex::new(0));
    let lock2 = Arc::new(Mutex::new(0));

    let lock1_clone = lock1.clone();
    let lock2_clone = lock2.clone();

    let thread1 = thread::spawn(move || {
        let _guard1 = lock1_clone.lock().unwrap();
        let _guard2 = lock2_clone.lock().unwrap();
        // 执行需要两把锁的操作
    });

    let thread2 = thread::spawn(move || {
        let _guard1 = lock1.lock().unwrap();
        let _guard2 = lock2.lock().unwrap();
        // 执行需要两把锁的操作
    });

    thread1.join().unwrap();
    thread2.join().unwrap();
}

在这个例子中，两个线程都先获取lock1，再获取lock2，避免了死锁。 2. 使用try_lock：Mutex提供了try_lock方法，尝试获取锁，如果锁不可用，立即返回Err。通过这种方式，可以避免线程无限等待锁，例如：

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

fn main() {
    let lock1 = Arc::new(Mutex::new(0));
    let lock2 = Arc::new(Mutex::new(0));

    let lock1_clone = lock1.clone();
    let lock2_clone = lock2.clone();

    let thread1 = thread::spawn(move || {
        match lock1_clone.try_lock() {
            Ok(guard1) => {
                match lock2_clone.try_lock() {
                    Ok(guard2) => {
                        // 执行需要两把锁的操作
                    },
                    Err(_) => {
                        // 处理获取lock2失败的情况，例如释放lock1
                        drop(guard1);
                    }
                }
            },
            Err(_) => {
                // 处理获取lock1失败的情况
            }
        }
    });

    let thread2 = thread::spawn(move || {
        // 类似thread1的逻辑
    });

    thread1.join().unwrap();
    thread2.join().unwrap();
}

减少锁的持有时间：尽量缩短线程持有锁的时间，减少其他线程等待的时间，降低死锁风险。例如，将不需要锁保护的操作移到锁的作用域之外。

排查死锁的策略和工具

使用std::sync::PoisonError：当一个线程在持有锁时发生恐慌（panic），该锁会进入“中毒”状态。后续尝试获取该锁会返回PoisonError。通过处理PoisonError，可以发现可能导致死锁的异常情况。例如：

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

fn main() {
    let lock = Arc::new(Mutex::new(0));
    let lock_clone = lock.clone();

    let thread1 = thread::spawn(move || {
        let mut data = lock_clone.lock().unwrap();
        // 模拟恐慌
        panic!("Panic in thread1");
    });

    let thread2 = thread::spawn(move || {
        match lock.lock() {
            Ok(_) => {
                // 正常获取锁
            },
            Err(e) => {
                println!("PoisonError: {:?}", e);
            }
        }
    });

    thread1.join().unwrap_err();
    thread2.join().unwrap();
}

使用线程分析工具：
- thread - profiler：可以分析线程的执行情况，包括线程的生命周期、资源占用等。通过分析线程的行为，找出可能的死锁点。
- gdb：结合Rust的调试信息，使用gdb可以在程序运行时查看线程状态，检查线程是否处于等待锁的状态，以及等待的是哪个锁。

可能导致死锁的场景及避免方法

场景：两个线程分别持有不同的锁，并尝试获取对方持有的锁。

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

fn main() {
    let lock1 = Arc::new(Mutex::new(0));
    let lock2 = Arc::new(Mutex::new(0));

    let lock1_clone = lock1.clone();
    let lock2_clone = lock2.clone();

    let thread1 = thread::spawn(move || {
        let _guard1 = lock1_clone.lock().unwrap();
        let _guard2 = lock2_clone.lock().unwrap();
    });

    let thread2 = thread::spawn(move || {
        let _guard2 = lock2.lock().unwrap();
        let _guard1 = lock1.lock().unwrap();
    });

    thread1.join().unwrap();
    thread2.join().unwrap();
}

避免方法：按照固定顺序获取锁，如上述“按照固定顺序获取锁”示例所示。

通过以上预防和排查方法，可以有效降低Rust多线程应用中死锁的发生概率，并在死锁发生时快速定位和解决问题。

星途面试题库

面试题：Rust多线程并发编程中的死锁预防及排查

知识考点

面试题答案

死锁产生的原因

预防死锁的方法

排查死锁的策略和工具

可能导致死锁的场景及避免方法