如何在C语言中调用函数并设置指定的返回等待时长？

嘿，这个问题问得很实际——在C里给函数调用加个超时限制确实是很多场景下的刚需，比如处理可能卡住的网络请求、外部命令调用或者IO操作。我来分享几种常用的实现思路，你可以根据自己的场景选：

1. 多线程 + 超时等待（通用场景首选） #

核心思路是把要执行的函数放到一个独立的子线程里跑，主线程只等待指定时长，到点不管子线程有没有执行完都继续走。这种方法兼容性好，几乎能给任何函数加超时，而且不会影响主线程的逻辑。

Linux下的示例代码： #

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <errno.h>

// 要执行的目标函数（模拟可能卡住的操作）
void* target_func(void* arg) {
    // 模拟耗时5秒的操作
    sleep(5);
    *(int*)arg = 42; // 将结果存入传入的内存地址
    return NULL;
}

int main() {
    pthread_t thread;
    int result = -1;
    const int timeout_sec = 3; // 设置3秒超时

    // 创建子线程执行目标函数
    if (pthread_create(&thread, NULL, target_func, &result) != 0) {
        perror("pthread_create failed");
        return 1;
    }

    // 用标准的pthread_timedjoin_np实现超时等待
    struct timespec ts;
    clock_gettime(CLOCK_REALTIME, &ts);
    ts.tv_sec += timeout_sec;

    int ret = pthread_timedjoin_np(thread, NULL, &ts);
    if (ret == 0) {
        printf("函数执行完成，结果：%d\n", result);
    } else if (ret == ETIMEDOUT) {
        printf("超时！函数未执行完成\n");
        // 可选：取消子线程（注意要确保目标函数支持取消点）
        pthread_cancel(thread);
        pthread_join(thread, NULL); // 等待子线程彻底退出
    } else {
        perror("pthread_join failed");
    }

    return 0;
}

Windows下的类似逻辑： #

用CreateThread创建线程，然后调用WaitForSingleObject设置超时，核心思路和Linux完全一致，只是API不同。

2. 信号（Signal）+ 定时器（单线程场景） #

如果不想引入多线程，可以用系统信号实现超时。比如在Linux下用alarm()设置定时器，到点触发SIGALRM信号，通过信号处理函数标记超时状态，让目标函数提前退出。

示例代码： #

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

volatile sig_atomic_t timeout_flag = 0; // 用sig_atomic_t保证信号安全

// 信号处理函数（只能调用异步信号安全的函数）
void timeout_handler(int sig) {
    timeout_flag = 1;
}

// 模拟可能卡住的函数
void slow_func() {
    while (!timeout_flag) {
        // 模拟循环操作，每秒检查一次超时标记
        sleep(1);
    }
}

int main() {
    // 注册SIGALRM信号处理函数
    struct sigaction sa;
    sa.sa_handler = timeout_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    sigaction(SIGALRM, &sa, NULL);

    alarm(3); // 设置3秒后触发超时信号
    printf("开始执行慢函数...\n");
    slow_func();

    if (timeout_flag) {
        printf("超时退出！\n");
    } else {
        printf("函数正常完成\n");
    }

    alarm(0); // 取消未触发的定时器
    return 0;
}

⚠️ 注意事项：

• 信号处理函数里只能调用异步信号安全的函数（比如不能用printf，上面示例仅作演示）；
• 若目标函数是系统调用（如read），信号可能会打断调用，导致函数提前返回错误（可通过SA_RESTART标志让部分系统调用自动重启，但不是所有都支持）；
• 全局超时标记必须用volatile sig_atomic_t修饰，避免编译器优化导致的错误；
• 同一个进程只能有一个alarm定时器，重复调用会覆盖之前的设置。

3. 针对IO操作的专属超时（高效推荐） #

如果你的函数是IO相关的（比如socket读写、文件操作），优先用系统自带的超时机制，比上面两种方法更高效：

• Socket操作：用setsockopt()设置SO_RCVTIMEO和SO_SNDTIMEO选项，recv/send等函数会自动在超时后返回；
• 文件/管道操作：用select()或poll()先检查文件描述符是否就绪，再执行读写，select()本身支持超时参数；
• 外部命令调用：用waitpid()配合WNOHANG轮询，或用select监控子进程的输出管道。

Socket超时示例： #

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <errno.h>

int main() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    // 此处省略连接服务器的代码...

    struct timeval timeout;
    timeout.tv_sec = 3;
    timeout.tv_usec = 0;

    // 设置接收超时
    if (setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout, sizeof(timeout)) < 0) {
        perror("setsockopt failed");
        close(sockfd);
        return 1;
    }

    char buf[1024];
    ssize_t ret = recv(sockfd, buf, sizeof(buf), 0);
    if (ret < 0) {
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            printf("接收超时！\n");
        } else {
            perror("recv failed");
        }
    } else {
        printf("收到数据：%.*s\n", (int)ret, buf);
    }

    close(sockfd);
    return 0;
}

总结一下 #

• 通用函数超时：优先用多线程方法，兼容性好，副作用小；
• 单线程场景：可以试试信号+定时器，但要严格注意信号安全问题；
• IO操作：直接用系统自带的超时机制，最高效可靠。

内容的提问来源于stack exchange，提问作者Jacob P John