主进程处理不同信号触发不同任务的实现方案咨询

你的整体思路是可行的，但确实存在几个潜在的细节问题需要注意，同时也有更高效的进程等待方式可以替代当前的指数退避睡眠循环。

潜在异常点 #

1. 共享变量的原子性风险 #

你当前使用普通int类型的flgsigint和flgsigtstp作为信号标志位，这在信号上下文与主程序上下文之间存在竞态隐患。C语言标准明确规定，只有volatile sig_atomic_t类型的变量才能保证在信号处理函数和主程序之间的访问是原子且无数据竞争的。例如，主循环在检查并清零标志位的过程中，如果信号触发修改标志位，可能导致状态不一致。

建议修改变量声明：

static volatile sig_atomic_t flgsigint = 0;
static volatile sig_atomic_t flgsigtstp = 0;

2. Sleep中断后的剩余时间未处理 #

你的代码没有处理sleep()的返回值。当sleep()被信号中断时，它会返回剩余的睡眠时间（而非0），但你的代码仍然会执行backoff = backoff << 2，这可能导致后续睡眠时长不符合预期。虽然你的信号处理函数会把backoff重置为初始值，这个问题在目标信号触发时不会显现，但如果没有信号的情况下睡眠被其他意外信号中断（比如未捕获的信号），就会出现backoff异常翻倍的情况。

3. 信号重复触发的覆盖（符合预期） #

你提到不在意短时间内相同信号的丢失，当前逻辑（标志位仅设置为1，多次触发不会累加）完全符合你的需求，这一点不属于异常，只是需要明确这是预期行为。

更优的进程等待方式 #

当前的指数退避睡眠循环虽然避免了忙等，但进程仍然会定期被唤醒，占用一定系统资源。更高效的方式是让进程主动挂起，直到收到目标信号，推荐两种方案：

方案1：使用sigwaitinfo直接等待信号 #

这种方式可以直接阻塞等待指定的信号集，不需要设置标志位，信号处理逻辑直接在主循环中完成，代码更简洁高效，且避免了共享变量的竞态问题。进程在没有信号时完全休眠，不会占用CPU资源。

示例代码：

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

int main() {
    sigset_t sigset;
    sigemptyset(&sigset);
    sigaddset(&sigset, SIGINT);
    sigaddset(&sigset, SIGTSTP);

    // 先阻塞目标信号，避免在sigwaitinfo之前被信号打断
    sigprocmask(SIG_BLOCK, &sigset, NULL);

    while (1) {
        siginfo_t info;
        // 阻塞等待信号，返回收到的信号编号
        int signo = sigwaitinfo(&sigset, &info);
        if (signo == -1) {
            perror("sigwaitinfo");
            exit(EXIT_FAILURE);
        }

        if (signo == SIGINT) {
            printf("main: gonna do some SIGINT stuff\n");
            // 执行SIGINT对应的任务
        } else if (signo == SIGTSTP) {
            printf("main: gonna do some SIGTSTP stuff\n");
            // 执行SIGTSTP对应的任务
        }
    }
    exit(0);
}

此外，sigwaitinfo还能获取信号的详细信息（比如发送者PID、信号附带的数据等），扩展性更强。

方案2：使用sigsuspend挂起等待信号 #

如果你想保留原有的信号处理函数逻辑，可以用sigsuspend替代sleep()，让进程在等待信号时挂起，直到收到信号才唤醒，同样避免定期唤醒的开销。

示例代码：

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

static volatile sig_atomic_t flgsigint = 0;
static volatile sig_atomic_t flgsigtstp = 0;

void sighandler(int signo) {
    if (signo == SIGINT)
        flgsigint = 1;
    else if (signo == SIGTSTP)
        flgsigtstp = 1;
}

int main() {
    struct sigaction act1;
    act1.sa_handler = sighandler;
    sigemptyset(&(act1.sa_mask));
    sigaddset(&(act1.sa_mask), SIGINT);
    sigaddset(&(act1.sa_mask), SIGTSTP);
    act1.sa_flags = 0;

    sigaction(SIGINT, &act1, NULL);
    sigaction(SIGTSTP, &act1, NULL);

    // 先阻塞目标信号，避免在sigsuspend前被触发
    sigset_t orig_mask;
    sigemptyset(&orig_mask);
    sigaddset(&orig_mask, SIGINT);
    sigaddset(&orig_mask, SIGTSTP);
    sigprocmask(SIG_BLOCK, &orig_mask, NULL);

    sigset_t wait_mask;
    sigemptyset(&wait_mask); // 临时解除所有信号阻塞，等待目标信号

    while (1) {
        // 挂起进程，直到收到信号才返回
        sigsuspend(&wait_mask);

        if (flgsigint) {
            printf("main: gonna do some SIGINT stuff\n");
            flgsigint = 0;
        }
        if (flgsigtstp) {
            printf("main: gonna do some SIGTSTP stuff\n");
            flgsigtstp = 0;
        }
    }
    exit(0);
}

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