如何在Linux中使用C语言实现延时功能？

在 Linux 中，可以使用 sleep 命令来延时执行任务。 sleep 5 将使程序暂停执行 5 秒。

在Linux操作系统中，延时（Delay）是编程和系统管理中常见的需求，通过使用C语言，开发者可以创建各种延时机制，以满足不同的应用需求，本文将深入探讨如何在Linux环境下使用C语言实现延时，并介绍相关的工具和技巧。

基本延时函数

sleep() 函数

sleep() 是一个常用的延时函数，它会使程序暂停执行指定的秒数，该函数定义在<unistd.h> 头文件中。

#include <stdio.h>
#include <unistd.h>
int main() {
    printf("Starting delay...
");
    sleep(5); // 延时5秒
    printf("Delay finished.
");
    return 0;
}

usleep() 函数

usleep() 函数允许更精细的延时控制，以微秒为单位，该函数同样定义在<unistd.h> 头文件中。

#include <stdio.h>
#include <unistd.h>
int main() {
    printf("Starting microsecond delay...
");
    usleep(5000000); // 延时5秒（5000000微秒）
    printf("Microsecond delay finished.
");
    return 0;
}

nanosleep() 函数

nanosleep() 函数提供纳秒级的延时精度，适用于需要高精度延时的场景，该函数定义在<time.h> 头文件中。

#include <stdio.h>
#include <time.h>
int main() {
    struct timespec ts;
    ts.tv_sec = 1;        // 秒
    ts.tv_nsec = 500000000L; // 纳秒
    printf("Starting nanosecond delay...
");
    nanosleep(&ts, NULL);
    printf("Nanosecond delay finished.
");
    return 0;
}

高级延时技巧

使用定时器（Timers）

Linux提供了多种定时器机制，如POSIX定时器和实时定时器，可以实现更复杂的延时逻辑。

POSIX定时器

POSIX定时器是一种简单易用的定时器，适用于大多数应用场景，以下示例展示了如何使用POSIX定时器进行延时：

#include <stdio.h>
#include <signal.h>
#include <time.h>
#include <unistd.h>
void timer_handler(int signum) {
    static int count = 0;
    printf("timer expired %d times
", ++count);
}
int main() {
    struct sigaction sa;
    struct itimerval timer;
    // 安装信号处理程序
    sa.sa_handler = &timer_handler;
    sa.sa_flags = SA_RESTART;
    sigaction(SIGALRM, &sa, NULL);
    // 配置定时器
    timer.it_value.tv_sec = 2;    // 初始延时2秒
    timer.it_value.tv_usec = 0;
    timer.it_interval.tv_sec = 2;  // 每隔2秒触发一次
    timer.it_interval.tv_usec = 0;
    setitimer(ITIMER_REAL, &timer, NULL);
    // 模拟长时间运行的程序
    while (1) {
        pause(); // 等待信号
    }
    return 0;
}

实时定时器（Real-Time Timer）

实时定时器提供了更高的精度和优先级，适用于对时间要求严格的应用。

#include <stdio.h>
#include <signal.h>
#include <time.h>
#include <string.h>
#include <sys/time.h>
void real_timer_handler(int signum) {
    static int count = 0;
    printf("real timer expired %d times
", ++count);
}
int main() {
    struct sigaction sa;
    struct itimerspec its;
    timer_t timerid;
    // 安装信号处理程序
    sa.sa_flags = SA_SIGINFO;
    sa.sa_handler = real_timer_handler;
    sigemptyset(&sa.sa_mask);
    if (sigaction(SIGRTMIN, &sa, NULL) == -1) {
        perror("sigaction");
        return 1;
    }
    // 创建定时器
    timer_create(CLOCK_REALTIME, NULL, &timerid);
    // 配置定时器
    its.it_value.tv_sec = 2;       // 初始延时2秒
    its.it_value.tv_nsec = 0;
    its.it_interval.tv_sec = 2;     // 每隔2秒触发一次
    its.it_interval.tv_nsec = 0;
    timer_settime(timerid, 0, &its, NULL);
    // 模拟长时间运行的程序
    while (1) {
        pause(); // 等待信号
    }
    return 0;
}

使用C语言实现循环延时

在某些情况下，可能需要实现一个自定义的循环延时，而不是依赖系统提供的延时函数，这可以通过测量时间戳来实现。

#include <stdio.h>
#include <time.h>
#include <sys/time.h>
void custom_delay(int seconds) {
    struct timeval start, end;
    long elapsed;
    gettimeofday(&start, NULL);
    do {
        gettimeofday(&end, NULL);
        elapsed = (end.tv_sec start.tv_sec) * 1000000L + end.tv_usec start.tv_usec;
    } while (elapsed < seconds * 1000000L); // 1秒 = 1000000微秒
}
int main() {
    printf("Starting custom delay...
");
    custom_delay(5); // 延时5秒
    printf("Custom delay finished.
");
    return 0;
}

结合多线程实现延时操作

在多线程环境中，可以使用线程和条件变量来实现延时操作，以下示例展示了如何在一个线程中延时，并在另一个线程中等待延时完成。

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
typedef struct {
    int delay_seconds;
    pthread_mutex_t mutex;
    pthread_cond_t cond;
    int done;
} thread_data_t;
void* delay_thread(void* arg) {
    thread_data_t* data = (thread_data_t*)arg;
    sleep(data->delay_seconds); // 延时指定秒数
    pthread_mutex_lock(&data->mutex);
    data->done = 1;
    pthread_cond_signal(&data->cond);
    pthread_mutex_unlock(&data->mutex);
    return NULL;
}
int main() {
    pthread_t thread;
    thread_data_t data;
    data.delay_seconds = 5; // 延时5秒
    pthread_mutex_init(&data.mutex, NULL);
    pthread_cond_init(&data.cond, NULL);
    data.done = 0;
    // 创建延时线程
    pthread_create(&thread, NULL, delay_thread, &data);
    // 主线程等待延时完成
    pthread_mutex_lock(&data.mutex);
    while (!data.done) {
        pthread_cond_wait(&data.cond, &data.mutex);
    }
    pthread_mutex_unlock(&data.mutex);
    printf("Delay completed.
");
    // 清理资源
    pthread_join(thread, NULL);
    pthread_mutex_destroy(&data.mutex);
    pthread.

小伙伴们，上文介绍了“c 延时 linux”的内容，你了解清楚吗？希望对你有所帮助，任何问题可以给我留言，让我们下期再见吧。