从第2章来看，底层时间驱动机制

sleep/usleep/nanosleep：简单但受限

使用者痛点：在高并发服务中。传统睡眠函数会导致线程阻塞、CPU 资源浪费还有难以统一事件处理。怎么说呢，

. 三种睡眠函数的演进

Linux 提供了三代睡眠函数。精度逐步提高：

┌─────────────────────────────────────────────────────────────────────┐
│ 睡眠函数演进史 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 第一代：sleep —— 秒级精度 │
│ ──────────────────────────── │
│ #include  │
│ unsigned int sleep;│
│ │
│ 特点： │
│ • 精度：秒级 │
│ • 返回值：返回剩余未睡眠秒数 │
│ • 状态：POSIX 标准，但已不推荐用于新代码 │
│ │
│ 第二代：usleep —— 微秒级精度 │
│ ──────────────────────────── │
│ #include  │
│ int usleep;│
│ │
│ 特点： │
│ • 精度：微秒级 │
│ • 返回值：成功返回0。失败返回- │
│ • 状态：POSIX‑2001 已标记为废弃 │
│ │
│ 第三代：nanosleep —— 纳秒级精度 │
│ ──────────────────────────── │
│ #include  │
│ int nanosleep(const struct timespec *req,│
│ struct timespec *rem);│
│ │
│ 特点： │
│ • 精度：纳秒级 │
│ • 参数：使用 timespec结构，更清晰 │
│ • 状态：POSIX 推荐，现代代码首选 │
└─────────────────────────────────────────────────────────────────────┘

. nanosleep 的内部原理

nanosleep 是现代 Linux 的首选。其内核实现流程如下：

┌─────────────────────────────────────────────────────────────────────┐
│ nanosleep 内核执行流程 │
├─────────────────────────────────────────────────────────────────────┤
| 使用者空间 内核空间 |
| | | |
| | nanosleep | |
| |------------------------► | |
| | | |
| | ┌──────┴──────┐ |
| | │ . 参数校验 │ |
| | └──────┬──────┘ |
|…，|
| └────────────── 定时到期 / 信号中断 / 被唤醒 ────────────────► |
| 返回值及 errno |
└─────────────────────────────────────────────────────────────────────┘

timespec结构体：

struct timespec {
time_t tv_sec;老实说，// 秒
long tv_nsec;// 纳秒
}，struct timespec req = { .tv_sec = 0,.tv_nsec = 500000000 };//500ms
struct timespec rem;其实，int ret = nanosleep;

. 精度实测：理论与现实的差距

下面的基准程序展示了三种睡眠函数在真实机器上的误差分布。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
class PrecisionTester {
public的观点是，using TimePoint = std::chrono::high_resolution_clock::time_point;static void TestSleep {
printf ===
");std这方面，:vector errors;const int test_count = 10;const int target_sec = 1;for {
auto start = Now;sleep，auto end = Now;其实，double actual = DurationMs;errors.push_back;}
PrintStats"。target_sec*1000,errors);}
static void TestUsleep {
printf ===
");std的观点是，:vector errors;说起来，const int test_count = 10;const int target_us = 10000;//10ms
for {
auto start = Now;usleep，说起来，auto end = Now;double actual = DurationMs;errors.push_back;}
PrintStats"。target_us/1000.0,errors);}
static void TestNanosleep {
printf ===
再看");std，:vector errors;const int test_count = 10;const long target_ns = 10000000L;//10ms
for {
struct timespec req={0,target_ns};struct timespec rem;auto start=Now;nanosleep，auto end=Now;double actual=DurationMs;errors.push_back;}
PrintStats",target_ns/1e6,errors);}
private:
static TimePoint Now{ return std::chrono::high_resolution_clock::now;}
static double DurationMs{
return std::chrono::duration.count;}
static void PrintStats(const char* name,double target_ms。const std::vector& err){
double sum=0,max=-1e9,min=1e9;for{ sum+=e，ifmax=e;ifmin=e，}
printf;printf，printf);printf
",sum/err.size。)/target_ms*100);printf，printf;printf，}
};不过，int main{
PrecisionTester::TestSleep;PrecisionTester::TestUsleep;PrecisionTester::TestNanosleep;}

典型测试结果：

=== Testing sleep ===
Function: sleep
再看Target。1000.000 ms
Samples:10
Avg Error: +15.342 ms
Max Error: +22.101 ms
Min Error: +8.567 ms
Jitter的观点是，+13.534 ms
=== Testing usleep ===
Function: usleep
从Target来看，10.000 ms
...

. 为什么不能用于高性能服务器？

使用者痛点一：阻塞式等待导致网络事件延迟；使用者痛点二：无法管理大量定时器；使用者痛点三：信号中断带来不确定性；使用者痛点四：线程资源浪费。

┌───────────────────────────────┐
│ sleep 系列在服务器中的问题 │
├───────────────────────────────┤
• 阻塞式等待，期间无法处理网络 I/O → 延迟达秒级
• 多定时器串行调用 → 累计误差、调度冲突
• 信号中断导致返回剩余时间。代码复杂化
• 每个定时器若使用独立线程 → 成千上万线程导致上下文切换开销
└───────────────────────────────┘

sleep 系列适合脚本或一次性延迟，在高性能服务器应采用事件驱动方式。

timerfd_create：定时器即文件描述符

. timerfd 的设计哲学

┌───────────────────────────────┐
│ timerfd 主要理念 │
├───────────────────────────────┤
传统定时器 → 独立对象，需要额外管理
timerfd → 定时器对象 → 文件描述符 → epoll统一管理
从优势来看。· 与网络 I/O 同一套事件循环
· 无需额外线程
· 纳秒级精度
· 可复用、可取消
❌ 局限：
· Linux 专属
· 大量 timerfd 会占用大量 fd
· 每次触发需 read 获取过期次数

. timerfd API详解

#include 
// 创建定时器 fd
int timerfd_create;// 设置一次性或周期性定时器
int timerfd_settime(int fd,int flags。const struct itimerspec *new_value,struct itimerspec *old_value);
// 获取当前设置
int timerfd_gettime;

struct itimerspec{
struct timespec it_interval;怎么说呢，// 周期间隔
struct timespec it_value;// 首次到期时间
}，

. 完整使用示例

#include 
#include 
#include 
#include 
#include 
#include 
class TimerFdDemo{
再看public，// 单次定时器
static void SingleShot{
int tfd=timerfd_create;struct itimerspec its={{{0。500000000}},{{0,0}}};// 第一次到期后不再触发
its.it_interval.tv_sec=0;its.it_interval.tv_nsec=0;按理说，timerfd_settime;uint64_t expirations;read,sizeof);printf，close;}
// 周期定时器
static void Periodic{
int tfd=timerfd_create;struct itimerspec its={{{0。200000000}},{{0,200000000}}};timerfd_settime;for{
uint64_t exp;read,sizeof);printf，话说回来，}
close;}
// 与 epoll 合作的示例
static void WithEpoll{
int ep_fd=epoll_create1;int t_fd=timerfd_create;struct epoll_event ev{EPOLLIN,};ev.data.fd=t_fd;epoll_ctl)，struct itimerspec its={{},{}};，its.it_interval.tv_nsec=100000000;//100ms 周期
its.it_value=its.it_interval;//立即开始
timerfd_settime,nullptr);while{
struct epoll_event events;int n=epoll_wait;// 永久阻塞等事件
if{perror;break，不过，}
for{
if{
uint64_t exp;read,sizeof);printf，}
}
if break;}
close，close;}
}，/* class end */
int main{
TimerFdDemo::SingleShot;TimerFdDemo::Periodic;TimerFdDemo::WithEpoll;}

. timerfd 的优势与局限

• Pain Point: 高并发服务器需要统一事件源，而传统多线程+sleep 模式导致锁竞争和上下文切换。
• 优势: 
  • 统一文件描述符。可直接加入 epoll，实现“单线程 I/O + 定时”。
  • Nano‑second 精度，由内核 high‑resolution timers 支持。
  • No extra thread – 减少资源使用情况。
• 局限: 
  • L​inux 专属，不跨网站。怎么说呢，
  • a large number of timers ⇒ many fds may hit per‑process limit.
• 说到*适用场景*。少量高精度、需要和网络 I/O 同步的服务；*不适用*: 跨网站或百万级别计时需求。

. epoll_wait 的超时参数——统一事件源的关键利刃

. 超时时间本质是“一次性定时器”

The fourth argument of epoll_wait,-1/0/>n ms​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​ ​​​​ ​​​​ ​​​​ ​​​​​ ​ ​ ​​​​​​​  ​ ​  ​​ ​​​​​ ​ ​ ​​​​​ ​​​​​​​​​​​​ `timeout` is essentially a one‑shot timer that tells kernel how long to block waiting for any registered event.

. 完整统一事件源实现

# include  # include  # include  # include  # include  # include  # include  # include  # include 

// 简易最小堆管理者... ... // 主循环主要： while{ int timeout=timerMgr.GetWaitTimeout;// 毫秒数，int n=epoll_wait;if continue，// …处理网络 IO，timerMgr.ProcessExpiredTimers;// 执行已到期回调，} ...

User Pain Point:

. 性能基准——不同实现下 epoll_wait 超时时间对比