面试题：Rust中如何创建和管理线程

创建线程基本步骤

引入标准库：在Rust中创建线程需要引入std::thread模块。通常在文件开头使用use std::thread;语句引入。
创建线程：使用thread::spawn函数来创建一个新线程。该函数接受一个闭包作为参数，闭包中的代码就是新线程要执行的代码。例如：

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        // 新线程执行的代码
        println!("This is a new thread!");
    });
    // 主线程可以继续执行其他代码
    // 如果需要等待新线程结束，可以调用handle.join()
    handle.join().unwrap();
}

线程间共享数据

使用Arc和Mutex：
- Arc（原子引用计数）用于在多个线程间共享数据的所有权，它允许数据在多个线程间安全地克隆。
- Mutex（互斥锁）用于保护共享数据，确保同一时间只有一个线程可以访问数据。
- 示例：

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

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

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

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

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

使用RwLock：当读操作远多于写操作时，可以使用RwLock（读写锁）。它允许多个线程同时进行读操作，但写操作时会独占锁，防止其他线程读写。
- 示例：

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

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

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

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

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

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

共享数据时可能遇到的问题及解决方案

数据竞争（Data Race）：
- 问题：多个线程同时访问和修改共享数据，没有适当的同步机制，导致数据不一致或未定义行为。
- 解决方案：使用Mutex、RwLock等同步原语来确保同一时间只有一个线程可以修改数据。如上述示例中，通过lock方法获取锁，在临界区访问和修改数据，离开临界区时自动释放锁。
死锁（Deadlock）：
- 问题：两个或多个线程相互等待对方释放锁，导致所有线程都无法继续执行。
- 解决方案：
  - 按顺序获取锁：确保所有线程以相同顺序获取多个锁，避免循环依赖。
  - 避免嵌套锁：尽量减少锁的嵌套使用，如果必须嵌套，仔细设计获取锁的顺序。
  - 使用try_lock方法：在获取锁时使用try_lock，如果无法获取锁，线程可以执行其他操作，避免无限等待。例如：

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

fn main() {
    let mutex1 = Arc::new(Mutex::new(()));
    let mutex2 = Arc::new(Mutex::new(()));

    let mutex1_clone = Arc::clone(&mutex1);
    let handle1 = thread::spawn(move || {
        if let Ok(_) = mutex1_clone.try_lock() {
            if let Ok(_) = mutex2.try_lock() {
                // 成功获取两个锁，可以执行操作
            }
        }
    });

    let mutex2_clone = Arc::clone(&mutex2);
    let handle2 = thread::spawn(move || {
        if let Ok(_) = mutex2_clone.try_lock() {
            if let Ok(_) = mutex1.try_lock() {
                // 成功获取两个锁，可以执行操作
            }
        }
    });

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

星途面试题库

面试题：Rust中如何创建和管理线程

知识考点

面试题答案

创建线程基本步骤

线程间共享数据

共享数据时可能遇到的问题及解决方案