timerfd fdgettime fdsetime系统调用及示例

#include <sys/timerfd.h> // 包含 timerfd 相关函数和结构体

// 创建一个定时器并返回文件描述符
int timerfd_create(int clockid, int flags);

// 获取定时器的当前设置
int timerfd_gettime(int fd, struct itimerspec *curr_value);

// 启动或重新设置定时器
int timerfd_settime(int fd, int flags, const struct itimerspec *new_value, struct itimerspec *old_value);

struct timespec {
    time_t tv_sec;  /* 秒 */
    long   tv_nsec; /* 纳秒 */
};

struct itimerspec {
    struct timespec it_interval; /* 定时器的时间间隔 (周期性定时器) */
    struct timespec it_value;    /* 首次超时的相对/绝对时间 */
};

#define _GNU_SOURCE // 启用 GNU 扩展
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/timerfd.h> // timerfd 相关
#include <poll.h>       // poll 相关
#include <string.h>
#include <errno.h>
#include <inttypes.h>   // 包含 PRIu64 宏，用于 printf uint64_t

// 辅助函数：打印 itimerspec 结构
void print_itimerspec(const char* prefix, const struct itimerspec *ts) {
    printf("%s: ", prefix);
    if (ts->it_value.tv_sec == 0 && ts->it_value.tv_nsec == 0) {
        printf("Timer is STOPPED\n");
    } else {
        printf("Next expiration in %ld.%09ld seconds\n", ts->it_value.tv_sec, ts->it_value.tv_nsec);
    }
    printf("     Interval: %ld.%09ld seconds\n", ts->it_interval.tv_sec, ts->it_interval.tv_nsec);
}

int main() {
    int tfd_one_shot, tfd_periodic;
    struct itimerspec one_shot_time, periodic_time;
    struct pollfd fds[3]; // 监听两个 timerfd 和 标准输入
    uint64_t expirations;
    ssize_t s;

    printf("--- Demonstrating timerfd ---\n");
    printf("PID: %d\n", getpid());

    // 1. 创建两个 timerfd
    // 一次性定时器，基于单调时钟
    tfd_one_shot = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC);
    if (tfd_one_shot == -1) {
        perror("timerfd_create one-shot");
        exit(EXIT_FAILURE);
    }
    printf("Created one-shot timerfd: %d\n", tfd_one_shot);

    // 周期性定时器，基于单调时钟，非阻塞
    tfd_periodic = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK);
    if (tfd_periodic == -1) {
        perror("timerfd_create periodic");
        close(tfd_one_shot);
        exit(EXIT_FAILURE);
    }
    printf("Created periodic timerfd: %d (non-blocking)\n", tfd_periodic);

    // 2. 设置一次性定时器：3秒后到期
    one_shot_time.it_value.tv_sec = 3;     // 3 秒后
    one_shot_time.it_value.tv_nsec = 0;
    one_shot_time.it_interval.tv_sec = 0;  // 一次性，不重复
    one_shot_time.it_interval.tv_nsec = 0;
    if (timerfd_settime(tfd_one_shot, 0, &one_shot_time, NULL) == -1) {
        perror("timerfd_settime one-shot");
        close(tfd_one_shot);
        close(tfd_periodic);
        exit(EXIT_FAILURE);
    }
    printf("Set one-shot timer to expire in 3 seconds.\n");

    // 3. 设置周期性定时器：立即启动，每 2 秒重复一次
    periodic_time.it_value.tv_sec = 0;     // 立即启动
    periodic_time.it_value.tv_nsec = 1;    // 纳秒设为1，确保立即触发第一次
    periodic_time.it_interval.tv_sec = 2;  // 每 2 秒重复
    periodic_time.it_interval.tv_nsec = 0;
    if (timerfd_settime(tfd_periodic, 0, &periodic_time, NULL) == -1) {
        perror("timerfd_settime periodic");
        close(tfd_one_shot);
        close(tfd_periodic);
        exit(EXIT_FAILURE);
    }
    printf("Set periodic timer to start immediately and repeat every 2 seconds.\n");

    // 4. 查询并打印初始定时器状态
    struct itimerspec curr_time;
    if (timerfd_gettime(tfd_one_shot, &curr_time) == 0) {
        print_itimerspec("One-shot timer initial state", &curr_time);
    }
    if (timerfd_gettime(tfd_periodic, &curr_time) == 0) {
        print_itimerspec("Periodic timer initial state", &curr_time);
    }

    // 5. 设置 poll 的文件描述符数组
    fds[0].fd = tfd_one_shot;
    fds[0].events = POLLIN;
    fds[1].fd = tfd_periodic;
    fds[1].events = POLLIN;
    fds[2].fd = STDIN_FILENO;
    fds[2].events = POLLIN;

    printf("\nEntering main loop. Waiting for timers or input (type 'quit' to exit)...\n");

    // 6. 主循环：使用 poll 等待事件
    int one_shot_done = 0;
    while (!one_shot_done) { // 循环直到一次性定时器完成
        int poll_num = poll(fds, 3, -1); // -1 表示无限期等待
        if (poll_num == -1) {
            if (errno == EINTR) {
                continue; // poll 被信号中断，继续等待
            } else {
                perror("poll");
                break;
            }
        }

        if (poll_num > 0) {
            // 检查一次性定时器
            if (fds[0].revents & POLLIN) {
                s = read(tfd_one_shot, &expirations, sizeof(expirations));
                if (s == sizeof(expirations)) {
                    printf("\n[ONE-SHOT TIMER] Expired! Expirations counted: %" PRIu64 "\n", expirations);
                    one_shot_done = 1; // 设置标志退出循环

                    // 再次查询状态，确认已停止
                    if (timerfd_gettime(tfd_one_shot, &curr_time) == 0) {
                        print_itimerspec("One-shot timer final state", &curr_time);
                    }
                } else {
                    perror("read one-shot timerfd");
                }
            }

            // 检查周期性定时器
            if (fds[1].revents & POLLIN) {
                s = read(tfd_periodic, &expirations, sizeof(expirations));
                if (s == sizeof(expirations)) {
                    printf("\n[PERIODIC TIMER] Expired! Expirations counted: %" PRIu64 "\n", expirations);
                    // 可以在这里处理周期性任务
                } else if (s == -1) {
                    if (errno != EAGAIN && errno != EWOULDBLOCK) {
                         perror("read periodic timerfd"); // 非 EAGAIN 的错误
                    } // EAGAIN/EWOULDBLOCK 是正常的，因为我们设置了 NONBLOCK
                }
            }

            // 检查标准输入
            if (fds[2].revents & POLLIN) {
                char buf[16];
                ssize_t nread = read(STDIN_FILENO, buf, sizeof(buf) - 1);
                if (nread > 0) {
                    buf[nread] = '\0';
                    printf("Read from stdin: %s", buf);
                    if (strncmp(buf, "quit\n", 5) == 0) {
                        printf("Exiting due to 'quit' command.\n");
                        break;
                    }
                } else if (nread == 0) {
                    printf("EOF on stdin (Ctrl+D). Exiting.\n");
                    break;
                }
            }
        }
    }

    // 7. 清理资源
    printf("\nClosing timerfds...\n");
    close(tfd_one_shot);
    close(tfd_periodic);
    printf("Program finished.\n");

    return 0;
}

# 假设代码保存在 timerfd_example.c 中
gcc -o timerfd_example timerfd_example.c

# 运行程序
./timerfd_example
# 程序会启动定时器，并在终端输出信息。
# 等待 3 秒后一次性定时器触发。
# 每 2 秒周期性定时器会触发。
# 输入 'quit' 并回车可以退出。