MST
星途 面试题库

面试题：Rust并行编程之线程与同步原语

在Rust中使用线程进行并行编程时，有哪些常见的同步原语？请描述`Mutex`和`RwLock`的适用场景，并通过代码示例展示如何在多线程环境下安全地共享数据，同时要处理好可能出现的死锁问题。
27.4万 热度难度
编程语言Rust

知识考点

AI 面试

面试题答案

一键面试

常见同步原语

在Rust中使用线程进行并行编程时，常见的同步原语有：

  • Mutex（互斥锁）：用于保证同一时间只有一个线程可以访问共享数据，通过锁定和解锁机制来实现线程安全。
  • RwLock（读写锁）：允许多个线程同时进行读操作，但只允许一个线程进行写操作。适用于读多写少的场景，提高并发性能。
  • Condvar（条件变量）：用于线程间的通信和同步，一个线程可以等待某个条件满足，其他线程可以通知该条件已满足。
  • Barrier（屏障）：用于同步多个线程，所有线程必须到达屏障点，然后才能一起继续执行。

Mutex适用场景

当需要保护共享数据，确保同一时间只有一个线程能访问该数据时，使用Mutex。比如，多个线程可能会修改同一个计数器，为防止数据竞争，需要使用Mutex。

RwLock适用场景

当共享数据的读操作远远多于写操作时，使用RwLock。例如，一个配置文件在程序运行期间很少被修改，但会被多个线程频繁读取。

代码示例

  1. 使用Mutex在多线程环境下安全共享数据
use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Final counter value: {}", *counter.lock().unwrap());
}
  1. 使用RwLock在多线程环境下安全共享数据
use std::sync::{Arc, RwLock};
use std::thread;

fn main() {
    let data = Arc::new(RwLock::new(String::from("initial data")));
    let mut handles = vec![];

    for _ in 0..5 {
        let data = Arc::clone(&data);
        let handle = thread::spawn(move || {
            let read_data = data.read().unwrap();
            println!("Read data: {}", read_data);
        });
        handles.push(handle);
    }

    for _ in 0..2 {
        let data = Arc::clone(&data);
        let handle = thread::spawn(move || {
            let mut write_data = data.write().unwrap();
            write_data.push_str(" appended");
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Final data: {}", *data.read().unwrap());
}

处理死锁问题

  1. 避免死锁的方法
    • 按顺序锁定：如果需要锁定多个锁，所有线程都按照相同的顺序锁定这些锁。例如，如果线程1需要锁定锁A和锁B，那么线程2也应该先锁定锁A，再锁定锁B。
    • 避免嵌套锁定：尽量减少一个线程内对多个锁的嵌套锁定，尤其是在可能出现死锁的情况下。
    • 使用try_lock方法：对于Mutex和RwLock，都有try_lock方法，该方法尝试获取锁，如果锁不可用，立即返回Err，而不是阻塞。可以利用这个方法来检测死锁并采取相应措施，比如释放已获取的锁并重新尝试。
use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let lock_a = Arc::new(Mutex::new(1));
    let lock_b = Arc::new(Mutex::new(2));

    let lock_a_clone = Arc::clone(&lock_a);
    let lock_b_clone = Arc::clone(&lock_b);

    let handle1 = thread::spawn(move || {
        if let Ok(mut guard_a) = lock_a_clone.try_lock() {
            println!("Thread 1 got lock A");
            if let Ok(mut guard_b) = lock_b_clone.try_lock() {
                println!("Thread 1 got lock B");
                // 使用锁保护的数据
            } else {
                println!("Thread 1 couldn't get lock B, releasing lock A");
            }
        }
    });

    let handle2 = thread::spawn(move || {
        if let Ok(mut guard_b) = lock_b.try_lock() {
            println!("Thread 2 got lock B");
            if let Ok(mut guard_a) = lock_a.try_lock() {
                println!("Thread 2 got lock A");
                // 使用锁保护的数据
            } else {
                println!("Thread 2 couldn't get lock A, releasing lock B");
            }
        }
    });

    handle1.join().unwrap();
    handle2.join().unwrap();
}

通过这些措施，可以有效避免死锁的发生，确保多线程程序的稳定性和可靠性。