请用C语言实现以下功能，用clock_gettime接口计算任务两次执行的时间间隔

#include <stdio.h>
#include <time.h>

int main() {
    struct timespec start, end;
    int i;

    // 获取开始时间
    clock_gettime(CLOCK_MONOTONIC, &start);

    // 执行任务
    for (i = 0; i < 100000000; i++) {
        // do something
    }

    // 获取结束时间
    clock_gettime(CLOCK_MONOTONIC, &end);

    // 计算时间间隔
    double elapsed_time = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1000000000.0;

    printf("Elapsed time: %f seconds\n", elapsed_time);

    return 0;
}

相关问题

蓝桥杯c语言中，时钟以4秒跳转一次，怎么解决

在蓝桥杯C语言竞赛中，如果遇到需要模拟时钟每4秒跳转一次的问题，你可以通过定时器函数结合条件判断来实现。这里是一个基本思路：

1. 首先，你需要一个全局变量或结构体来存储当前的时间，可以设为一个整数表示从比赛开始以来的秒数，初始值为0。

#include <stdio.h>
#include <time.h>

// 假设这个全局变量叫clock_value，初始化为0
int clock_value = 0;

2. 然后，你可以利用`CLOCKS_PER_SEC`宏（通常等于1000，代表每秒的时间片数）来获取微秒级别的计数，并转换成秒：

#define TIMER_INTERVAL (4 * CLOCKS_PER_SEC)

3. 定义一个函数用于更新时间并检查是否达到4秒间隔，可以使用`difftime()`函数计算两个时间点的差值，然后判断是否跳转：

void updateClock() {
    struct timespec now, prev;
    clock_gettime(CLOCK_MONOTONIC, &now);
    if (clock_gettime(CLOCK_MONOTONIC, &prev) == -1) {
        perror("Failed to get time");
        return;
    }
    
    double elapsed_time = difftime(now.tv_sec, prev.tv_sec) + (now.tv_nsec - prev.tv_nsec) / 1e9; // 转换到秒
    
    // 更新时钟值
    clock_value += elapsed_time;

    // 检查跳转，四秒内加一
    if (elapsed_time >= TIMER_INTERVAL) {
        clock_value += TIMER_INTERVAL; // 如果大于4秒，则直接跳转到下一个4秒
    }

    printf("Current Time: %d seconds\n", clock_value); // 打印当前时间
}

4. 在需要更新时钟的地方调用`updateClock()`函数即可。

注意，这只是一个基础的示例，实际编写时可能还需要考虑错误处理和其他细节，例如线程安全问题，因为这里是用全局变量模拟的。此外，在比赛中，可能还会有限制，比如禁止使用特定库函数，所以需查看具体的题目要求进行调整。

Linux的C语言编程，如何在一个进程里用signal设置2个2ms定时器，其中一个触发时打印“触发定时器1”，另外一个触发时打印“出发定时器2”，并且这两个定时器回调函数是两个不同的函数，请给出具体的代码并加以说明

在Linux C语言编程中，你可以利用`<signal.h>`库来处理信号，特别是通过`sigset_t`结构和`timerfd_create`系统调用来设置定时器。下面是一个简单的示例，展示了如何在一个进程中设置两个2毫秒的定时器，每个定时器有一个单独的回调函数：

#include <stdio.h>
#include <signal.h>
#include <sys/time.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>

// 定义回调函数
void timer1_callback(int signum) {
    printf("触发定时器1\n");
}

void timer2_callback(int signum) {
    printf("触发定时器2\n");
}

int main() {
    // 创建两个文件描述符用于定时器
    int t1_fd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK);
    if (t1_fd == -1) {
        perror("创建timer1_fd失败");
        return 1;
    }

    int t2_fd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK);
    if (t2_fd == -1) {
        perror("创建timer2_fd失败");
        close(t1_fd);
        return 1;
    }

    // 设置信号处理器
    struct sigaction action1, action2;
    memset(&action1, 0, sizeof(action1));
    memset(&action2, 0, sizeof(action2));
    action1.sa_handler = timer1_callback;
    action2.sa_handler = timer2_callback;

    sigemptyset(&action1.sa_mask);
    sigemptyset(&action2.sa_mask);

    action1.sa_flags = SA_RESTART;
    action2.sa_flags = SA_RESTART;

    if (sigaction(SIGRTMIN+1, &action1, NULL) < 0) {
        perror("设置timer1的信号处理器");
        close(t2_fd);
        close(t1_fd);
        return 1;
    }
    
    if (sigaction(SIGRTMIN+2, &action2, NULL) < 0) {
        perror("设置timer2的信号处理器");
        close(t2_fd);
        close(t1_fd);
        return 1;
    }

    // 设置定时器
    struct itimerspec itspec1, itspec2;
    itspec1.it_value.tv_nsec = 2 * 1000 * 1000; // 2ms
    itspec1.it_interval.tv_nsec = itspec1.it_value.tv_nsec; // 持续2ms

    itspec2.it_value.tv_nsec = 2 * 1000 * 1000; // 同样2ms
    itspec2.it_interval.tv_nsec = itspec2.it_value.tv_nsec; // 持续2ms

    if (clock_gettime(CLOCK_MONOTONIC, &itspec1.it_value) < 0 ||
        clock_gettime(CLOCK_MONOTONIC, &itspec2.it_value) < 0) {
        perror("获取时间戳失败");
        close(t2_fd);
        close(t1_fd);
        return 1;
    }

    if (timerfd_settime(t1_fd, 0, &itspec1, NULL) < 0) {
        perror("设置timer1的时间");
        close(t2_fd);
        close(t1_fd);
        return 1;
    }

    if (timerfd_settime(t2_fd, 0, &itspec2, NULL) < 0) {
        perror("设置timer2的时间");
        close(t2_fd);
        close(t1_fd);
        return 1;
    }

    printf("定时器已设置，等待定时器触发...\n");

    // 阻塞主循环，直到定时器触发
    while (true) {
        fd_set fds;
        FD_ZERO(&fds);
        FD_SET(t1_fd, &fds);
        FD_SET(t2_fd, &fds);
        struct timeval tv = {0, 500000}; // 每隔500us检查一次
        int result = select(FD_SETSIZE, &fds, NULL, NULL, &tv);
        if (result == -1 && errno != EINTR) {
            perror("select出错");
            break;
        } else if (result > 0) {
            if (FD_ISSET(t1_fd, &fds)) {
                timer1_callback(SIGRTMIN+1);
            } else if (FD_ISSET(t2_fd, &fds)) {
                timer2_callback(SIGRTMIN+2);
            }
        }
    }

    close(t1_fd);
    close(t2_fd);
    return 0;
}

在这个例子中，我们首先创建了两个`timerfd`文件描述符，然后分别设置了它们的信号处理器（`timer1_callback`和`timer2_callback`）。接着，我们设置两个定时器，每个定时器的间隔都是2毫秒，并在信号处理器中处理相应的信号。最后，通过`select`循环阻塞地等待定时器触发。