使用pthreads实现计算提前终止的合理性及相关问题咨询

问题背景 #

我有一个C语言程序，需执行耗时不确定的计算任务，无法预先估算时长。该程序具备命令行界面，目前我通常通过如下方式运行：

./program
do calculation 243

程序启动计算后，若耗时过久，我会按下Ctrl+C终止程序再重启执行其他计算。现在我希望程序能在按下q键或10秒超时后自动终止计算。

我已通过pthreads实现预期功能，但不确定该方案是否推荐，是否存在内存泄漏等问题。以下是我的代码：

void *pthread_getc(void *ptr) {
    char c = '\0';
    while (c != 'q')
        c = getc(stdin);
    pthread_cancel((pthread_t)ptr);
}

void *pthread_sleep(void *ptr) {
    sleep(10);
    pthread_cancel((pthread_t)ptr);
}

void pthread_cancellable(void *(*ptr)(void *), struct arg *arg) {
    pthread_t thread_main, thread_getc, thread_sleep;

    pthread_create(&thread_main, NULL, ptr, (void *)arg);
    pthread_create(&thread_getc, NULL, pthread_getc, (void *)thread_main);
    pthread_create(&thread_sleep, NULL, pthread_sleep, (void *)thread_main);

    pthread_join(thread_main, NULL);
    pthread_cancel(thread_getc);
    pthread_cancel(thread_sleep);
    pthread_join(thread_getc, NULL);
    pthread_join(thread_sleep, NULL);
}

设计思路是pthread_getc和pthread_sleep均可终止计算线程（thread_main），计算线程终止后再终止这两个线程。只需调用pthread_cancellable，传入计算函数及参数即可。

我有三个疑问：

1. 该方案是否会引发内存泄漏等问题？
2. C语言中有无更简便的实现方式？
3. 计算线程被重复取消、取消已结束的线程会有什么影响？

1. 现有方案的内存泄漏及潜在问题 #

• 内存/资源泄漏风险：如果计算线程被pthread_cancel异步取消时，正持有动态分配的内存、文件句柄或其他资源，且未设置取消清理函数（pthread_cleanup_push/pthread_cleanup_pop），这些资源将无法被释放，直接导致内存泄漏或资源泄漏。
• 线程取消的安全性问题：默认情况下pthread_cancel是异步取消，若计算线程正在执行非取消安全的函数（如malloc、memcpy这类操作内部状态的函数），可能会破坏程序内部一致性（比如堆结构损坏），引发后续崩溃或异常行为。
• 其他细节问题：
  • getc(stdin)是阻塞调用，若计算线程提前结束，thread_getc会一直阻塞等待输入，直到被取消或按下q，这部分逻辑本身没问题，但如果输入缓冲区有残留字符，可能会意外触发退出。
  • 线程资源回收：你在计算线程结束后，通过pthread_cancel+pthread_join回收了thread_getc和thread_sleep的资源，这部分不会产生线程资源泄漏，所有创建的线程都被正确join释放。

2. 更简便的实现方式 #

无需额外创建两个线程，用信号+IO多路复用的轻量方案即可实现需求，同时避免线程异步取消的风险：

示例代码 #

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/select.h>
#include <unistd.h>
#include <pthread.h>

// 全局原子标志，标记是否终止计算
volatile sig_atomic_t should_exit = 0;

void sigalrm_handler(int sig) {
    should_exit = 1;
}

// 计算任务函数（放到单独线程中执行）
void *calculation_task(void *arg) {
    int task_arg = *(int *)arg;
    while (!should_exit) {
        // 模拟耗时计算逻辑
        printf("Running calculation with arg %d...\n", task_arg);
        sleep(1);
    }
    printf("Calculation terminated gracefully.\n");
    return NULL;
}

int main() {
    // 设置SIGALRM信号处理函数，10秒后触发超时
    signal(SIGALRM, sigalrm_handler);
    alarm(10);

    // 启动计算线程
    int task_arg = 243;
    pthread_t calc_thread;
    pthread_create(&calc_thread, NULL, calculation_task, &task_arg);

    fd_set read_fds;
    struct timeval tv;

    while (!should_exit) {
        // 重置文件描述符集和超时时间
        FD_ZERO(&read_fds);
        FD_SET(STDIN_FILENO, &read_fds);
        tv.tv_sec = 0;
        tv.tv_usec = 100000; // 100ms轮询一次

        // 监听标准输入，同时处理超时
        int ret = select(STDIN_FILENO + 1, &read_fds, NULL, NULL, &tv);
        if (ret > 0 && FD_ISSET(STDIN_FILENO, &read_fds)) {
            char c = getc(stdin);
            if (c == 'q' || c == 'Q') {
                should_exit = 1;
            }
        }
    }

    // 等待计算线程退出，清理资源
    pthread_join(calc_thread, NULL);
    alarm(0); // 取消未触发的闹钟
    return 0;
}

方案优势 #

• 仅创建一个计算线程，主线程专注处理输入和超时，避免多线程同步的复杂度。
• 通过should_exit原子标志让计算线程优雅退出，完全规避异步取消带来的程序一致性风险。
• 信号+select的组合同时实现超时和键盘输入监听，逻辑清晰且资源占用低。

3. 重复取消/取消已结束线程的影响 #

• 取消已结束的线程：对已终止的线程调用pthread_cancel，函数会返回ESRCH错误（找不到指定线程ID），但不会导致程序崩溃或其他异常，只是这次调用没有实际效果。你的代码中在计算线程结束后调用pthread_cancel(thread_getc)和pthread_cancel(thread_sleep)，如果这两个线程已经自行退出，pthread_cancel会返回错误，但不影响程序运行。
• 线程被重复取消：若thread_getc和thread_sleep同时触发（比如刚好10秒时按下q），会两次调用pthread_cancel(thread_main)。第一次调用会将计算线程标记为待取消状态，如果线程还未处理取消，第二次调用不会产生额外影响；如果线程已经处理完取消并终止，第二次调用就和取消已结束线程的情况一致，返回ESRCH错误，无其他危害。

内容的提问来源于stack exchange，提问作者spinosarus123