线程 Thread 创建 ​

核心概念 ​

Rust 的线程模型采用 1:1 映射,即每个 Rust 线程对应一个操作系统线程。线程通过 std::thread 模块创建和管理。Rust 的所有权系统和类型系统在编译期就保证了线程安全——数据竞争在编译时被捕获,而不是等到运行时才崩溃。创建线程使用 thread::spawn() 函数,它接受一个闭包作为线程的执行体。主线程结束时,所有未被 join 的子线程会被直接终止。

rust
use std::thread;
use std::time::Duration;

fn main() {
    // 创建一个新线程
    thread::spawn(|| {
        for i in 1..=5 {
            println!("子线程: 计数 {}", i);
            thread::sleep(Duration::from_millis(50));
        }
    });

    // 主线程继续执行
    for i in 1..=3 {
        println!("主线程: 计数 {}", i);
        thread::sleep(Duration::from_millis(50));
    }

    // 注意:主线程结束后,子线程可能还没执行完就被终止了
    println!("主线程结束");
}

线程的基本属性 ​

rust
use std::thread;

fn main() {
    // 获取当前线程的信息
    let current = thread::current();
    println!("当前线程ID: {:?}", current.id());
    println!("当前线程名称: {:?}", current.name());  // 主线程名称是 "main"

    // 创建带名称的线程
    let builder = thread::Builder::new()
        .name("工作线程".to_string())   // 设置线程名称
        .stack_size(4 * 1024 * 1024);   // 设置栈大小为 4MB

    let handle = builder.spawn(|| {
        let current = thread::current();
        println!("线程名称: {:?}", current.name());
        println!("线程ID: {:?}", current.id());
    }).unwrap();

    handle.join().unwrap();

    // 获取可用的 CPU 核心数
    let cpus = thread::available_parallelism()
        .map(|n| n.get())
        .unwrap_or(1);
    println!("可用核心数: {}", cpus);
}

多个线程同时运行 ​

rust
use std::thread;
use std::time::Duration;

fn main() {
    // 创建多个线程
    let mut handles = Vec::new();

    for i in 0..5 {
        // 每个线程有自己的 i 值(闭包捕获)
        let handle = thread::spawn(move || {
            println!("线程 {} 开始", i);
            thread::sleep(Duration::from_millis(100 * (i as u64 + 1)));
            println!("线程 {} 完成", i);
            i * i  // 返回值
        });
        handles.push(handle);
    }

    // 等待所有线程完成并收集结果
    let results: Vec<i32> = handles.into_iter()
        .map(|h| h.join().unwrap())
        .collect();

    println!("所有线程结果: {:?}", results);
}

线程与所有权 ​

rust
use std::thread;

fn main() {
    let data = String::from("hello");

    // 错误:闭包借用了 data,但线程可能比 data 活得更久
    // thread::spawn(|| {
    //     println!("{}", data);  // 编译错误
    // });

    // 正确:使用 move 将 data 移入线程
    let handle = thread::spawn(move || {
        println!("线程中的数据: {}", data);
        // data 现在属于这个线程
    });

    // data 已被移走,主线程不能再使用
    // println!("{}", data);  // 编译错误

    handle.join().unwrap();

    // 如果需要在主线程中也使用数据,先 clone
    let shared = String::from("共享数据");
    let clone_for_thread = shared.clone();

    let handle = thread::spawn(move || {
        println!("线程: {}", clone_for_thread);
    });

    println!("主线程: {}", shared);  // 主线程用原始值
    handle.join().unwrap();
}

线程的返回值 ​

rust
use std::thread;

fn main() {
    // 线程闭包的返回值可以通过 join() 获取
    let handle = thread::spawn(|| {
        let mut sum = 0;
        for i in 1..=100 {
            sum += i;
        }
        sum  // 返回计算结果
    });

    // join() 返回 Result<T, Box<dyn Any + Send>>
    match handle.join() {
        Ok(result) => println!("线程返回: {}", result),
        Err(_) => println!("线程发生了 panic"),
    }

    // 多个线程的返回值
    let handles: Vec<_> = (0..5)
        .map(|i| {
            thread::spawn(move || {
                // 每个线程计算不同区间的和
                let start = i * 20 + 1;
                let end = (i + 1) * 20;
                let sum: i32 = (start..=end).sum();
                (i, start, end, sum)
            })
        })
        .collect();

    println!("\n分段求和:");
    let mut total = 0;
    for handle in handles {
        let (id, start, end, sum) = handle.join().unwrap();
        println!("  线程{}: {}~{} 的和 = {}", id, start, end, sum);
        total += sum;
    }
    println!("总和: {}", total);
}

基本示例 ​

用线程实现并行文件处理的模拟:

rust
use std::thread;
use std::time::{Duration, Instant};

// 模拟处理一个任务
fn process_task(task_id: usize, data: &str) -> String {
    // 模拟耗时操作
    thread::sleep(Duration::from_millis(200));
    format!("任务{}: 处理了 '{}' ({}字符)", task_id, data, data.len())
}

fn main() {
    let tasks = vec![
        "分析用户数据",
        "生成报告",
        "发送通知",
        "更新缓存",
        "同步数据库",
        "清理临时文件",
    ];

    // === 串行处理 ===
    let start = Instant::now();
    let mut serial_results = Vec::new();
    for (i, task) in tasks.iter().enumerate() {
        serial_results.push(process_task(i, task));
    }
    let serial_time = start.elapsed();

    println!("=== 串行结果 ===");
    for result in &serial_results {
        println!("  {}", result);
    }
    println!("串行耗时: {:?}\n", serial_time);

    // === 并行处理 ===
    let start = Instant::now();
    let handles: Vec<_> = tasks.iter().enumerate()
        .map(|(i, &task)| {
            let task_owned = task.to_string();
            thread::spawn(move || {
                process_task(i, &task_owned)
            })
        })
        .collect();

    let parallel_results: Vec<String> = handles.into_iter()
        .map(|h| h.join().unwrap())
        .collect();
    let parallel_time = start.elapsed();

    println!("=== 并行结果 ===");
    for result in &parallel_results {
        println!("  {}", result);
    }
    println!("并行耗时: {:?}\n", parallel_time);

    // 加速比
    let speedup = serial_time.as_secs_f64() / parallel_time.as_secs_f64();
    println!("加速比: {:.1}x", speedup);
}

常见问题 ​

问题一:主线程结束后子线程会怎样?

主线程退出时,所有未被 join 的子线程会被直接终止,不管它们是否完成。如果需要等待子线程完成,必须调用 handle.join()。

问题二:线程闭包为什么需要 move?

线程的生命周期不确定,可能比创建它的作用域活得更久。如果闭包借用了局部变量,变量可能已被释放。move 将数据所有权转移到线程中,保证安全。

问题三:可以创建多少个线程?

取决于操作系统限制和可用内存。每个线程默认有 2-8MB 的栈空间(可通过 Builder::stack_size 调整)。创建过多线程会消耗大量内存和系统资源。

问题四:线程 panic 会影响其他线程吗?

默认情况下,一个线程 panic 不会影响其他线程。join() 会返回 Err,里面包含 panic 信息。但如果主线程 panic(且没有被捕获),整个程序会终止。

适用场景 ​

  • CPU 密集型任务:并行计算、数据处理
  • IO 密集型任务:并行网络请求、文件操作
  • 后台任务:日志写入、数据同步
  • 任务分解:将大任务拆分为小任务并行执行

注意事项 ​

  • 主线程结束会终止未 join 的子线程
  • 线程闭包通常需要 move 获取所有权
  • 每个线程有独立的栈空间,创建太多会耗尽内存
  • thread::spawn 返回 JoinHandle,用于等待和获取结果
  • thread::Builder 可以自定义线程名称和栈大小
  • 线程间共享数据需要 Arc、Mutex 等同步原语

总结 ​

Rust 使用 std::thread::spawn() 创建操作系统线程,传入一个闭包作为线程的执行体。闭包通常需要 move 来获取外部数据的所有权。spawn 返回 JoinHandle,通过 join() 等待线程完成并获取返回值。thread::Builder 可以设置线程名称和栈大小。主线程结束时未 join 的子线程会被终止。Rust 的所有权和类型系统在编译期保证线程安全,数据竞争在编译时就被捕获。线程适合 CPU 密集型和 IO 密集型的并行任务。