理解和处理Rust互斥锁中毒

coding到灯火阑珊发表于 1年以前 | 总阅读数：469 次

当谈到Rust中的并发编程时，互斥锁是确保线程安全最常用的工具之一。互斥或互斥原语是一种同步原语，它允许多个线程访问共享资源，同时确保一次只有一个线程可以访问它。

然而，互斥锁可能是一把双刃剑，因为虽然它可以防止数据竞争并确保线程安全，但它也可能导致互斥锁中毒的问题。在本文中，我们将解释什么是互斥锁中毒，为什么会发生，以及如何从中恢复。

什么是互斥锁中毒？

当线程在持有互斥锁时发生恐慌，互斥锁中毒就有可能发生。当线程发生故障时，它可能使互斥锁处于不一致的状态，使其他线程无法获得该锁。这可能导致死锁或其他类型的同步问题。

为了更好地理解这个问题，让我们看一个例子。假设我们有一个互斥锁来保护对共享资源的访问，比如一个整数向量：

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

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

    // 生成两个访问共享数据的线程
    for i in 0..2 {
        let shared_data = Arc::clone(&shared_data);
        std::thread::spawn(move || {
            let mut data = shared_data.lock().unwrap();
            data.push(i);
        });
    }
}

在本例中，我们首先使用std::sync模块中的Mutex类型创建一个名为shared_data的互斥锁，这个互斥锁保护对整数向量的访问，它最初被设置为包含值[1,2,3]。

接下来，我们使用Arc类型创建一个指向Mutex的共享引用计数指针，这允许我们在多个线程之间共享互斥锁的所有权，并确保只有在所有线程都完成对互斥锁的访问后才删除互斥锁。

然后使用在0..2范围内的for循环生成两个线程，对于每次迭代，我们使用Arc::clone方法克隆对互斥锁的共享引用，并使用std::thread::spawn函数将其传递给线程。在传递给spawn的闭包中，我们使用lock()方法获取互斥锁，该方法返回一个守卫，授予对共享数据的独占访问权。

为了防止数据竞争，我们使用push()方法将每个线程的索引‘i’添加到vector中。因为传递给spawn的闭包获取了对互斥锁引用的所有权，所以我们使用move关键字将所有权转移到闭包。

这段代码的问题在于，如果一个线程在持有锁时发生了恐慌，它可能会使互斥锁处于不一致的状态，从而使另一个线程无法获得锁。这就是所谓的互斥锁中毒，它会导致等待该锁的其他线程无限期地阻塞。

为什么会发生互斥锁中毒？

互斥锁中毒的发生与Rust的互斥锁实现的工作方式有关。当线程在持有互斥锁时发生恐慌时，互斥锁就会处于中毒状态。在这种状态下，任何后续获取锁的尝试都会导致一个错误，表明互斥锁已经中毒。

这样做的原因是为了防止数据损坏和其他同步问题。如果线程在持有锁时出现恐慌，它可能会使共享资源处于不一致的状态，从而导致其他线程错误地读取或修改数据。通过将互斥锁标记为有毒，Rust的互斥锁实现确保任何后续获取锁的尝试都将失败，从而防止对共享资源的进一步损害。

如何从互斥体中毒中恢复

从互斥锁中毒中恢复可能很棘手，但并非不可能。第一步是检测它，这可以通过检查互斥锁lock()方法的结果来完成。如果该方法返回一个错误，意味着互斥锁已经中毒。

下面是一个如何检测互斥锁中毒并从中恢复的例子：

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

fn main() {
    let shared_data = Arc::new(Mutex::new(vec![1, 2, 3]));
    let mut handles = Vec::new();
    // 生成两个访问共享数据的线程
    for i in 0..2 {
        let shared_data = shared_data.clone(); // Clone the Arc to move into the thread
        let handle = thread::spawn(move || {
            let mut data: MutexGuard<Vec<i32>> = match shared_data.lock() {
                Ok(guard) => guard,
                Err(poisoned) => {
                    // 处理互斥锁中毒
                    let guard = poisoned.into_inner();
                    println!("Thread {} recovered from mutex poisoning: {:?}", i, *guard);
                    guard
                }
            };
            // Use the data
            println!("Thread {}: {:?}", i, *data);
            data.push(i);
        });
        handles.push(handle);
    }

    // Wait for the threads to finish
    for handle in handles {
        handle.join().unwrap();
    }
}

在上面的代码中，我们首先使用Arc和Mutex创建了一个共享数据结构。然后我们生成两个线程来访问共享数据。

当线程尝试使用lock()方法获取共享资源上的锁时，它返回Result类型。如果锁没有中毒，结果为Ok，线程可以安全地使用数据。如果锁已中毒，则Result是带有中毒变体的Err。

为了处理互斥锁中毒，我们使用match语句对lock()方法的结果进行模式匹配。如果锁是中毒的，我们调用Poisoned上的into_inner()方法，该方法返回底层数据。

然后我们可以执行恢复步骤，例如记录错误或将当前线程的数据添加到共享资源中。一旦恢复完成，我们返回guard，以便其他线程可以访问共享数据。

在示例代码中，我们将当前线程的索引添加到共享向量中，并打印一条消息，表明线程已经从互斥锁中毒中恢复过来。然而，在实际场景中，恢复步骤可能涉及更复杂的逻辑。

需要注意的是，在Rust中，一旦互斥锁中毒，随后所有获取该锁的尝试都将导致中毒错误。因此，必须处理互斥锁中毒，以确保并发代码的正确行为。