在 Linux 系统编程中,使用 timerfd
实现定时器功能是一种更加可靠、高效、灵活的方式。本文是对 timerfd
的简单使用,不涉及太过深入知识,熟练掌握几个常用 API,实现定时器功能。
timerfd
是 Linux 为用户程序提供的一个定时器接口。这个接口基于文件描述符,通过文件描述符的可读事件进行超时通知,它可以用来实现高精度的定时器,以及与 I/O
多路复用机制(如select
、poll
、epoll
等)进行配合,实现异步事件驱动的程序。
优点:
高精度:timerfd使用内核提供的高精度计时器,精度通常可以达到纳秒级别,相对于使用系统时间的方式,误差更小,定时器的精度更高。
资源占用低:timerfd使用内核提供的异步I/O机制,可以将定时器超时事件通知给应用程序,而不需要应用程序不断地轮询,从而避免了大量的CPU资源占用,提高了系统性能。
灵活性强:timerfd可以设置不同的定时器超时时间,并且可以同时管理多个定时器,可以根据应用程序的需要进行灵活配置。
可移植性好:timerfd是Linux内核提供的标准接口,可以在不同的Linux系统上使用,具有很好的可移植性。
常用的 API
接口:
#include
int timerfd_create(int clockid, int flags);
int timerfd_settime(int fd, int flags, const struct itimerspec *new_value, struct itimerspec *old_value);
int timerfd_gettime(int fd, struct itimerspec *curr_value);
timerfd_create
timerfd_create(CLOCK_REALTIME, 0); // 使用系统实时时间作为计时基准,阻塞模式。
clockid:
CLOCK_REALTIME:使用系统实时时钟,可以被修改;
CLOCK_MONOTONIC:使用系统单调时钟,不能被修改;
flags:
TFD_NONBLOCK:非阻塞模式,read操作不会阻塞;
TFD_CLOEXEC:创建的文件描述符将在执行exec时关闭。
timerfd_settime
timerfd_settime(fd, TFD_TIMER_ABSTIME, &new_value, NULL);
// 计时器文件描述符fd,初始状态new_value,并且采用绝对时间。(0:相对,1:绝对)
fd: timerfd_create函数创建的定时器文件描述符
flags: 可以设置为0或者TFD_TIMER_ABSTIME,用于指定定时器的绝对时间或者相对时间
new_value: 是一个指向itimerspec结构体的指针,用于指定新的定时器参数;
old_value: 是一个指向itimerspec结构体的指针,用于获取旧的定时器参数。
timerfd_gettime
// timerfd_gettime是一个用于获取timerfd定时器的当前超时时间的系统调用。
// 它可以用于查询定时器的当前状态,以便在需要时进行调整。
curr_value是指向itimerspec结构体的指针,用于存储当前定时器的超时时间和间隔。
itimerspec
结构体定义如下:struct timespec {
time_t tv_sec; // seconds
long tv_nsec; // nanoseconds
};
struct itimerspec {
struct timespec it_interval; // Interval for periodic timer
struct timespec it_value; // Initial expiration
};
#include
int clock_settime(clockid_t clockid, const struct timespec *tp);
int clock_gettime(clockid_t clockid, struct timespec *tp);
clock_settime
// 用于设置系统时钟的时间
// clock_settime函数所设置的时间值会影响到所有基于该时钟的时间函数,例如gettimeofday、clock_gettime等。
// 在Linux系统中,只有特权进程(即具有root权限的进程)才能修改系统时钟。
clock_gettime
clock_gettime(CLOCK_MONOTONIC, &start); // 基于系统启动时间的单调递增时钟,获取到的结构体值赋给start
clockid:
CLOCK_MONOTONIC:提供了一个单调递增的时钟,不受系统时间被改变的影响。
CLOCK_REALTIME:供了当前的日期和时间,但是受系统时间被改变的影响。
官方简单示例:(man手册查看)
#include
#include
#include
#include /* Definition of PRIu64 */
#include
#include
#include /* Definition of uint64_t */
#define handle_error(msg) \
do { perror(msg); exit(EXIT_FAILURE); } while (0)
static void
print_elapsed_time(void)
{
static struct timespec start; // 静态,只用于第一次赋值
struct timespec curr;
static int first_call = 1;
int secs, nsecs;
if (first_call) {
first_call = 0;
if (clock_gettime(CLOCK_MONOTONIC, &start) == -1)
handle_error("clock_gettime");
}
if (clock_gettime(CLOCK_MONOTONIC, &curr) == -1)
handle_error("clock_gettime");
secs = curr.tv_sec - start.tv_sec;
nsecs = curr.tv_nsec - start.tv_nsec;
if (nsecs < 0) {
secs--;
nsecs += 1000000000;
}
printf("%d.%03d: ", secs, (nsecs + 500000) / 1000000);
}
int
main(int argc, char *argv[])
{
struct itimerspec new_value;
int max_exp, fd;
struct timespec now;
uint64_t exp, tot_exp;
ssize_t s;
if ((argc != 2) && (argc != 4)) {
fprintf(stderr, "%s init-secs [interval-secs max-exp]\n", // 这里需要输入参数:(第一次到期,间隔,次数)
argv[0]);
exit(EXIT_FAILURE);
}
if (clock_gettime(CLOCK_REALTIME, &now) == -1)
handle_error("clock_gettime");
/* Create a CLOCK_REALTIME absolute timer with initial
expiration and interval as specified in command line */
new_value.it_value.tv_sec = now.tv_sec + atoi(argv[1]);
new_value.it_value.tv_nsec = now.tv_nsec;
if (argc == 2) {
new_value.it_interval.tv_sec = 0;
max_exp = 1;
} else {
new_value.it_interval.tv_sec = atoi(argv[2]);
max_exp = atoi(argv[3]);
}
new_value.it_interval.tv_nsec = 0;
fd = timerfd_create(CLOCK_REALTIME, 0);
if (fd == -1)
handle_error("timerfd_create");
if (timerfd_settime(fd, TFD_TIMER_ABSTIME, &new_value, NULL) == -1)
handle_error("timerfd_settime");
print_elapsed_time();
printf("timer started\n");
for (tot_exp = 0; tot_exp < max_exp;) {
s = read(fd, &exp, sizeof(uint64_t));
if (s != sizeof(uint64_t))
handle_error("read");
tot_exp += exp;
print_elapsed_time();
printf("read: %" PRIu64 "; total=%" PRIu64 "\n", exp, tot_exp);
}
exit(EXIT_SUCCESS);
}
timerfd
的基本使用:
#include
#include // EAGAIN
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define handle_error(msg) \
do { perror(msg); exit(EXIT_FAILURE); } while (0)
int g_exp = 1; // 第四个参数,执行次数
int g_timerfd = -1; // 计时器fd
struct timespec g_current; // 当前时间结构体
bool g_running = true;
void stop_timer(int); // 前置声明
void signal_handler(int signum) {
stop_timer(g_timerfd);
close(g_timerfd);
g_timerfd = -1;
g_running = false;
// exit(EXIT_FAILURE);
}
// man timerfd_create
int create_timer() {
// int fd = timerfd_create(CLOCK_MONOTONIC, 0);
int fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
if (fd == -1)
handle_error("create_timer failed");
return fd;
}
void init_timer(int timerfd, time_t secs, long nsecs, time_t interval_secs, long interval_nsecs) {
struct itimerspec new_value;
new_value.it_value.tv_sec = secs;
new_value.it_value.tv_nsec = nsecs;
new_value.it_interval.tv_sec = interval_secs;
new_value.it_interval.tv_nsec = interval_nsecs;
if (timerfd_settime(timerfd, 0, &new_value, NULL) == -1)
handle_error("init_time failed");
}
void stop_timer(int timerfd) {
struct itimerspec new_value;
new_value.it_value.tv_sec = 0;
new_value.it_value.tv_nsec = 0;
new_value.it_interval.tv_sec = 0;
new_value.it_interval.tv_nsec = 0;
if (timerfd_settime(timerfd, 0, &new_value, NULL) == -1)
handle_error("stop_timer failed");
}
// 打印间隔时间
static void print_elapsed_time() {
static struct timespec start;
static int first_call = 1;
if (first_call) {
first_call = 0;
if (clock_gettime(CLOCK_MONOTONIC, &start) == -1)
handle_error("clock_gettime failed");
}
if (clock_gettime(CLOCK_MONOTONIC, &g_current) == -1)
handle_error("clock_gettime failed");
time_t secs = g_current.tv_sec - start.tv_sec;
long nsecs = g_current.tv_nsec - start.tv_nsec;
if (nsecs < 0) {
secs -= 1;
nsecs += 1000000000;
}
printf("%ld.%03ld: ", secs, (nsecs + 500000) / 1000000);
}
// 工作线程
void *work_function(void *timerfd) {
int fd = *(int *)timerfd;
uint64_t exp;
for (int cnt = 0; cnt < g_exp && g_running; cnt++) {
int ret = read(fd, &exp, sizeof(uint64_t));
if (ret == sizeof(uint64_t)) {
print_elapsed_time();
} else { // 非阻塞模式,死循环,消耗CPU
cnt -= 1;
}
}
return NULL;
}
int main(int argc, char *argv[]) {
// 注册信号
signal(SIGINT, signal_handler); // kill -l
if (argc != 4) {
fprintf(stderr, "Usage %s init-secs interval-secs max-exp\n", argv[0]);
exit(EXIT_FAILURE);
}
g_timerfd = create_timer();
init_timer(g_timerfd, atoi(argv[1]), 0, atoi(argv[2]), 0);
g_exp = atoi(argv[3]);
print_elapsed_time(); // 第一次
pthread_t tid;
pthread_create(&tid, NULL, work_function, &g_timerfd);
pthread_join(tid, NULL);
return 0;
}
上例程序是非阻塞的timerfd
,极大占用CPU资源。
timerfd、eventfd、signalfd配合epoll使用,可以构造出一个零轮询的程序,但程序没有处理的事件时,程序是被阻塞的。epoll_wait阻塞监听事件。
eventfd
:#include
int eventfd(unsigned int initval, int flags);
// 其中initval参数是eventfd的初始值,通常设置为0即可,表示初始时没有事件发生。
// flags参数是eventfd的标志位,通常设置为0即可,表示没有特殊要求。
// 函数返回值是eventfd的文件描述符,可以用于后续的读写操作。
eventfd是Linux系统调用中的一种文件描述符类型,它可以用于在进程间传递事件通知。当一个进程调用eventfd创建一个事件文件描述符时,它会得到一个文件描述符,可以使用该文件描述符进行读写操作。当另一个进程写入数据到该文件描述符时,它会唤醒正在等待读取该文件描述符的进程。这样,可以实现进程间的事件通知,而无需使用显式的信号量或者管道等机制。
eventfd的使用非常简单,只需要调用eventfd函数创建一个事件文件描述符,然后使用read和write函数进行读写操作即可。eventfd还支持select、poll、epoll等多路复用机制,可以方便地将其集成到事件驱动的程序中。
代码如下:
fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
g_eventfd = eventfd(0, 0);
int epollfd = epoll_create(2);
if (epollfd == -1)
handle_error("epoll_create failed");
struct epoll_event ev_timer;
ev_timer.events = EPOLLIN;
ev_timer.data.fd = fd;
epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev_timer);
struct epoll_event ev_event;
ev_event.events = EPOLLIN;
ev_event.data.fd = g_eventfd;
epoll_ctl(epollfd, EPOLL_CTL_ADD, g_eventfd, &ev_event);
const int max_events = 2;
struct epoll_event events[max_events];
详见代码:
#include
#include // EAGAIN
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define handle_error(msg) \
do { perror(msg); exit(EXIT_FAILURE); } while (0)
int g_exp = 1; // 第四个参数,执行次数
int g_timerfd = -1; // 计时器fd
struct timespec g_current; // 当前时间结构体
bool g_running = true;
int g_eventfd; // a file descriptor for event notification
void stop_timer(int); // 前置声明
void signal_handler(int signum) {
stop_timer(g_timerfd);
g_timerfd = -1;
g_running = false;
uint64_t g_eventfd_val = 10086; // 64位无符号!!!;不要用 -1
write(g_eventfd, &g_eventfd_val, sizeof(uint64_t));
}
// man timerfd_create
int create_timer() {
// int fd = timerfd_create(CLOCK_MONOTONIC, 0);
int fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
if (fd == -1)
handle_error("create_timer failed");
return fd;
}
void init_timer(int timerfd, time_t secs, long nsecs, time_t interval_secs, long interval_nsecs) {
struct itimerspec new_value;
new_value.it_value.tv_sec = secs;
new_value.it_value.tv_nsec = nsecs;
new_value.it_interval.tv_sec = interval_secs;
new_value.it_interval.tv_nsec = interval_nsecs;
if (timerfd_settime(timerfd, 0, &new_value, NULL) == -1)
handle_error("init_time failed");
}
void stop_timer(int timerfd) {
struct itimerspec new_value;
new_value.it_value.tv_sec = 0;
new_value.it_value.tv_nsec = 0;
new_value.it_interval.tv_sec = 0;
new_value.it_interval.tv_nsec = 0;
if (timerfd_settime(timerfd, 0, &new_value, NULL) == -1)
handle_error("stop_timer failed");
}
// 打印间隔时间
static void print_elapsed_time() {
static struct timespec start;
static int first_call = 1;
if (first_call) {
first_call = 0;
if (clock_gettime(CLOCK_MONOTONIC, &start) == -1)
handle_error("clock_gettime failed");
}
if (clock_gettime(CLOCK_MONOTONIC, &g_current) == -1)
handle_error("clock_gettime failed");
time_t secs = g_current.tv_sec - start.tv_sec;
long nsecs = g_current.tv_nsec - start.tv_nsec;
if (nsecs < 0) {
secs -= 1;
nsecs += 1000000000;
}
printf("%ld.%03ld\n", secs, (nsecs + 500000) / 1000000);
}
// 工作线程
void *work_function(void *timerfd) {
int fd = *(int *)timerfd;
int epollfd = epoll_create(2);
if (epollfd == -1)
handle_error("epoll_create failed");
struct epoll_event ev_timer;
ev_timer.events = EPOLLIN;
ev_timer.data.fd = fd;
epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev_timer);
struct epoll_event ev_event;
ev_event.events = EPOLLIN;
ev_event.data.fd = g_eventfd;
epoll_ctl(epollfd, EPOLL_CTL_ADD, g_eventfd, &ev_event);
const int max_events = 2;
struct epoll_event events[max_events];
uint64_t exp;
for (int cnt = 0; cnt < g_exp && g_running; cnt++) {
int nfd = epoll_wait(epollfd, events, max_events, -1);
if (nfd > 0) {
for (int i = 0; i < nfd; i++) {
if (events[i].data.fd == fd) {
int ret = read(fd, &exp, sizeof(uint64_t));
if (ret == sizeof(uint64_t)) {
print_elapsed_time();
}
} else if (events[i].data.fd == g_eventfd) {
int ret = read(g_eventfd, &exp, sizeof(uint64_t));
if (ret == sizeof(uint64_t)) {
if (exp == 10086) { // 64位无符号!!!;不要用 -1
close(fd);
epoll_ctl(epollfd, EPOLL_CTL_DEL, fd, NULL);
close(g_eventfd);
epoll_ctl(epollfd, EPOLL_CTL_DEL, g_eventfd, NULL);
return NULL;
}
}
}
}
}
}
close(fd);
epoll_ctl(epollfd, EPOLL_CTL_DEL, fd, NULL);
close(g_eventfd);
epoll_ctl(epollfd, EPOLL_CTL_DEL, g_eventfd, NULL);
return NULL;
}
int main(int argc, char *argv[]) {
// 注册信号
// signal(SIGINT, signal_handler); // kill -l
signal(SIGUSR1, signal_handler); // kill -SIGUSR1 : 使用 SIGUSR1 和 SIGUSR2 信号来进行信号传递。这两个信号是专门为用户定义的信号,可以用于进程间通信或者在同一进程的不同线程之间进行通信。
if (argc != 4) {
fprintf(stderr, "Usage %s init-secs interval-secs max-exp\n", argv[0]);
exit(EXIT_FAILURE);
}
g_eventfd = eventfd(0, 0);
if (g_eventfd == -1)
handle_error("eventfd failed");
g_timerfd = create_timer();
init_timer(g_timerfd, atoi(argv[1]), 0, atoi(argv[2]), 0);
g_exp = atoi(argv[3]);
print_elapsed_time(); // 第一次
pthread_t tid;
pthread_create(&tid, NULL, work_function, &g_timerfd);
pthread_join(tid, NULL);
return 0;
}
运行示例:(1s第一次到期,每个3s定时一次,总共10次,kill杀死信号后结束程序)