thread::sleep
核心概念
thread::sleep 让当前线程暂停执行指定的时间。它接受一个 std::time::Duration 参数,表示至少暂停多久。注意"至少"——操作系统的线程调度可能导致实际暂停时间比指定的稍长,但不会更短。sleep 不消耗 CPU 资源,暂停期间线程处于休眠状态,操作系统可以将 CPU 时间分配给其他线程。sleep 是阻塞操作,在异步代码中应该用 tokio::time::sleep 等异步版本代替。
use std::thread;
use std::time::{Duration, Instant};
fn main() {
let start = Instant::now();
println!("[{:.0}ms] 开始", start.elapsed().as_millis());
// 暂停 500 毫秒
thread::sleep(Duration::from_millis(500));
println!("[{:.0}ms] 500ms 后", start.elapsed().as_millis());
// 暂停 1 秒
thread::sleep(Duration::from_secs(1));
println!("[{:.0}ms] 再过 1 秒", start.elapsed().as_millis());
// 暂停 200 微秒(精度取决于操作系统)
thread::sleep(Duration::from_micros(200));
println!("[{:.0}ms] 200 微秒后", start.elapsed().as_millis());
}Duration 的创建方式
use std::time::Duration;
use std::thread;
fn main() {
// 从秒创建
let one_sec = Duration::from_secs(1);
// 从毫秒创建
let half_sec = Duration::from_millis(500);
// 从微秒创建
let short = Duration::from_micros(100);
// 从纳秒创建
let tiny = Duration::from_nanos(1000);
// 从浮点秒数创建
let precise = Duration::from_secs_f64(0.75);
// Duration 可以做算术
let total = one_sec + half_sec;
let doubled = half_sec * 2;
println!("1秒: {:?}", one_sec);
println!("0.5秒: {:?}", half_sec);
println!("0.75秒: {:?}", precise);
println!("总计: {:?}", total);
println!("翻倍: {:?}", doubled);
// sleep(Duration::ZERO) 不保证让出 CPU
thread::sleep(Duration::ZERO);
// 实际 sleep 精度测试
let start = std::time::Instant::now();
thread::sleep(Duration::from_millis(100));
let actual = start.elapsed();
println!("\n请求 100ms,实际 {:?}", actual);
}sleep 在多线程中的应用
use std::thread;
use std::time::{Duration, Instant};
fn main() {
let start = Instant::now();
// 多个线程用不同的 sleep 时间模拟不同任务
let mut handles = Vec::new();
for i in 0..5 {
let start = start.clone();
handles.push(thread::spawn(move || {
let sleep_ms = 100 * (i as u64 + 1);
println!("[{:>4}ms] 线程{} 开始 (将睡眠 {}ms)",
start.elapsed().as_millis(), i, sleep_ms);
thread::sleep(Duration::from_millis(sleep_ms));
println!("[{:>4}ms] 线程{} 醒来",
start.elapsed().as_millis(), i);
i
}));
}
// 主线程也可以 sleep
println!("[{:>4}ms] 主线程等待中...", start.elapsed().as_millis());
for handle in handles {
let id = handle.join().unwrap();
println!("[{:>4}ms] 线程{} 已 join", start.elapsed().as_millis(), id);
}
}用 sleep 实现定时器和轮询
use std::thread;
use std::time::{Duration, Instant};
fn main() {
// === 简单定时器 ===
println!("=== 倒计时 ===");
for i in (1..=5).rev() {
println!(" {}...", i);
thread::sleep(Duration::from_millis(300));
}
println!(" 时间到!");
// === 轮询模式 ===
println!("\n=== 轮询检查 ===");
let start = Instant::now();
let timeout = Duration::from_secs(2);
let poll_interval = Duration::from_millis(300);
let mut attempt = 0;
loop {
attempt += 1;
let elapsed = start.elapsed();
if elapsed >= timeout {
println!(" 超时!共尝试 {} 次", attempt);
break;
}
// 模拟检查某个条件
let progress = (elapsed.as_millis() as f64 / timeout.as_millis() as f64 * 100.0) as u32;
println!(" 第{}次检查: 进度 {}%", attempt, progress);
if progress >= 80 {
println!(" 条件满足!在第{}次检查时完成", attempt);
break;
}
thread::sleep(poll_interval);
}
// === 周期性任务 ===
println!("\n=== 心跳 ===");
let heartbeat_count = 5;
for i in 1..=heartbeat_count {
println!(" 心跳 #{}", i);
if i < heartbeat_count {
thread::sleep(Duration::from_millis(200));
}
}
}sleep 的精度与注意事项
use std::thread;
use std::time::{Duration, Instant};
fn main() {
// 测试不同时间粒度的精度
let tests = vec![
("1ms", Duration::from_millis(1)),
("10ms", Duration::from_millis(10)),
("50ms", Duration::from_millis(50)),
("100ms", Duration::from_millis(100)),
("500ms", Duration::from_millis(500)),
];
println!("=== sleep 精度测试 ===");
println!("{:>8} | {:>10} | {:>8}", "请求", "实际", "误差");
println!("{}", "-".repeat(34));
for (label, duration) in tests {
let start = Instant::now();
thread::sleep(duration);
let actual = start.elapsed();
let error_us = actual.as_micros() as i64 - duration.as_micros() as i64;
println!("{:>8} | {:>8}us | {:>+6}us", label, actual.as_micros(), error_us);
}
// 用 sleep 做间隔时注意累积误差
println!("\n=== 累积误差演示 ===");
let start = Instant::now();
let interval = Duration::from_millis(100);
for i in 1..=10 {
thread::sleep(interval);
let actual = start.elapsed().as_millis();
let expected = 100 * i as u128;
let drift = actual as i64 - expected as i64;
println!(" 第{:>2}次: 预期 {}ms, 实际 {}ms, 偏移 {:+}ms",
i, expected, actual, drift);
}
}基本示例
用 sleep 模拟一个多阶段任务执行系统:
use std::thread;
use std::time::{Duration, Instant};
#[derive(Debug)]
struct Task {
name: String,
duration_ms: u64,
}
impl Task {
fn new(name: &str, duration_ms: u64) -> Self {
Task {
name: name.to_string(),
duration_ms,
}
}
fn execute(&self) -> String {
thread::sleep(Duration::from_millis(self.duration_ms));
format!("{} 完成 ({}ms)", self.name, self.duration_ms)
}
}
fn main() {
let tasks = vec![
Task::new("数据加载", 200),
Task::new("预处理", 150),
Task::new("模型推理", 300),
Task::new("后处理", 100),
Task::new("结果保存", 150),
];
// 串行执行
let start = Instant::now();
println!("=== 串行执行 ===");
for task in &tasks {
let result = task.execute();
println!(" {}", result);
}
let serial_time = start.elapsed();
println!("串行总耗时: {:?}\n", serial_time);
// 并行执行
let start = Instant::now();
println!("=== 并行执行 ===");
let handles: Vec<_> = tasks.iter()
.map(|task| {
let name = task.name.clone();
let duration_ms = task.duration_ms;
thread::spawn(move || {
thread::sleep(Duration::from_millis(duration_ms));
format!("{} 完成 ({}ms)", name, duration_ms)
})
})
.collect();
for handle in handles {
let result = handle.join().unwrap();
println!(" {}", result);
}
let parallel_time = start.elapsed();
println!("并行总耗时: {:?}", parallel_time);
println!("\n加速比: {:.1}x",
serial_time.as_secs_f64() / parallel_time.as_secs_f64());
// 带进度显示的执行
println!("\n=== 带进度 ===");
let total_steps = 10;
let step_duration = Duration::from_millis(150);
for step in 1..=total_steps {
thread::sleep(step_duration);
let progress = step * 100 / total_steps;
let bar_filled = progress / 5;
let bar_empty = 20 - bar_filled;
print!("\r [{}{}] {}%",
"#".repeat(bar_filled),
".".repeat(bar_empty),
progress);
}
println!("\n 处理完成!");
}常见问题
问题一:sleep 的精度怎么样?
取决于操作系统。Windows 上默认精度约 15ms(可通过 timeBeginPeriod 调整),Linux 上通常在 1ms 左右。短时间的 sleep(如几微秒)实际暂停时间可能远大于请求值。
问题二:sleep(Duration::ZERO) 有什么用?
理论上暂停 0 时间,但不保证让出 CPU 给其他线程。如果需要主动让出 CPU,用 thread::yield_now()。
问题三:sleep 会消耗 CPU 吗?
不会。sleep 期间线程处于内核的等待队列中,不占用 CPU 时间。这和"忙等待"(busy waiting,用循环检查时间)不同。
问题四:异步代码中可以用 thread::sleep 吗?
不推荐。thread::sleep 会阻塞整个线程,在异步运行时中会阻塞执行器线程,影响其他任务的执行。应该用异步运行时提供的 sleep(如 tokio::time::sleep)。
适用场景
- 模拟延迟:测试中模拟网络延迟或处理时间
- 轮询间隔:定时检查某个条件
- 限速:控制操作的执行频率
- 定时任务:简单的周期性操作
注意事项
sleep保证至少暂停指定时间,实际可能更长- 精度取决于操作系统,短时间 sleep 误差较大
sleep不消耗 CPU,但会阻塞当前线程- 异步代码中不应使用
thread::sleep - 累积多次 sleep 会有误差累积
Duration::ZERO不保证让出 CPU,用yield_now()代替
总结
thread::sleep 让当前线程暂停至少指定的时间,接受 Duration 参数。暂停期间不消耗 CPU,线程处于休眠状态。实际暂停时间可能比请求的稍长,精度取决于操作系统(通常 1-15ms 级别)。sleep 常用于模拟延迟、轮询间隔、限速等场景。在异步代码中应使用异步版本的 sleep。多次 sleep 会有误差累积,对精度要求高的场景需要补偿。Duration 可以从秒、毫秒、微秒、纳秒或浮点秒数创建,也支持加减乘除运算。