线程 Thread 创建
核心概念
Rust 的线程模型采用 1:1 映射,即每个 Rust 线程对应一个操作系统线程。线程通过 std::thread 模块创建和管理。Rust 的所有权系统和类型系统在编译期就保证了线程安全——数据竞争在编译时被捕获,而不是等到运行时才崩溃。创建线程使用 thread::spawn() 函数,它接受一个闭包作为线程的执行体。主线程结束时,所有未被 join 的子线程会被直接终止。
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!("主线程结束");
}线程的基本属性
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);
}多个线程同时运行
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);
}线程与所有权
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();
}线程的返回值
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);
}基本示例
用线程实现并行文件处理的模拟:
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 ¶llel_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 密集型的并行任务。