Linux 信号机制：从 kill -9 到可靠信号

#include <signal.h>

void handler(int sig) {
    /* 处理信号 */
}

int main(void) {
    signal(SIGINT, handler);  /* 不可靠，行为因平台而异 */
    /* ... */
}

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

void handler(int sig) {
    const char msg[] = "Caught signal\n";
    write(STDOUT_FILENO, msg, sizeof(msg) - 1);
}

int main(void) {
    struct sigaction sa;
    sa.sa_handler = handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;  /* 自动重启被中断的系统调用 */

    if (sigaction(SIGINT, &sa, NULL) == -1) {
        perror("sigaction");
        return 1;
    }

    while (1) {
        pause();
    }
    return 0;
}

/* 典型服务关闭流程 */
kill(pid, SIGTERM);       /* 请求优雅退出 */
sleep(30);                /* 等待 */
if (kill(pid, 0) == 0) {  /* 进程是否仍存在 */
    kill(pid, SIGKILL);   /* 强制终止 */
}

#include <signal.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>

void sigchld_handler(int sig) {
    int saved_errno = errno;
    pid_t pid;
    int status;

    /* WNOHANG: 非阻塞，尽可能回收所有已终止子进程 */
    while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
        char buf[64];
        int n = snprintf(buf, sizeof(buf), "reaped child %d\n", (int)pid);
        write(STDERR_FILENO, buf, n);
    }
    errno = saved_errno;  /* 恢复 errno，避免覆盖被中断的系统调用错误码 */
}

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

static int self_pipe[2];

void signal_handler(int sig) {
    int saved_errno = errno;
    char byte = (char)sig;
    write(self_pipe[1], &byte, 1);  /* 异步信号安全 */
    errno = saved_errno;
}

int setup_self_pipe(void) {
    if (pipe(self_pipe) == -1) return -1;
    fcntl(self_pipe[0], F_SETFL, O_NONBLOCK);
    fcntl(self_pipe[1], F_SETFL, O_NONBLOCK);

    struct sigaction sa;
    sa.sa_handler = signal_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    sigaction(SIGTERM, &sa, NULL);
    sigaction(SIGINT, &sa, NULL);
    return self_pipe[0];
}

/* 主循环中:
 *   将 self_pipe[0] 加入 epoll/poll 的监听集合
 *   可读时 read() 字节，根据值执行对应逻辑
 */

#include <sys/signalfd.h>
#include <signal.h>
#include <unistd.h>

int setup_signalfd(void) {
    sigset_t mask;
    sigemptyset(&mask);
    sigaddset(&mask, SIGTERM);
    sigaddset(&mask, SIGINT);
    sigaddset(&mask, SIGUSR1);

    /* 阻塞信号，使其只能通过 signalfd 接收 */
    sigprocmask(SIG_BLOCK, &mask, NULL);

    int fd = signalfd(-1, &mask, SFD_NONBLOCK | SFD_CLOEXEC);
    return fd;
}

/* 主循环中 read(signalfd, &siginfo, sizeof(siginfo)) */

sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGTERM);
sigaddset(&set, SIGINT);
pthread_sigmask(SIG_BLOCK, &set, NULL);

/* 工作线程继承阻塞掩码，不会收到信号 */
/* 专用线程: */
int sig;
sigwait(&set, &sig);  /* 同步等待，线程安全 */
handle_shutdown(sig);

#define _GNU_SOURCE
#include <signal.h>
#include <sys/signalfd.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>

static volatile sig_atomic_t should_exit = 0;
static volatile sig_atomic_t reload_config = 0;

/* 简单场景下用 volatile sig_atomic_t 原子标志也可以 */
void basic_handler(int sig) {
    if (sig == SIGTERM || sig == SIGINT)
        should_exit = 1;
    else if (sig == SIGHUP)
        reload_config = 1;
}

/* 可靠方案：signalfd + 事件循环 */
int main(void) {
    sigset_t mask;
    sigemptyset(&mask);
    sigaddset(&mask, SIGTERM);
    sigaddset(&mask, SIGINT);
    sigaddset(&mask, SIGHUP);
    sigaddset(&mask, SIGUSR1);

    if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1) {
        perror("sigprocmask");
        return 1;
    }

    int sfd = signalfd(-1, &mask, SFD_NONBLOCK | SFD_CLOEXEC);
    if (sfd == -1) {
        perror("signalfd");
        return 1;
    }

    /* 将 sfd 加入 epoll/poll，此处简化为循环 read */
    struct signalfd_siginfo fdsi;
    while (!should_exit) {
        ssize_t s = read(sfd, &fdsi, sizeof(fdsi));
        if (s == -1) {
            if (errno == EAGAIN || errno == EINTR)
                continue;
            perror("read");
            break;
        }

        switch (fdsi.ssi_signo) {
        case SIGTERM:
        case SIGINT:
            should_exit = 1;
            break;
        case SIGHUP:
            reload_config = 1;
            break;
        case SIGUSR1:
            /* dump stats */
            break;
        }

        if (reload_config) {
            reload_config = 0;
            /* 安全地重载配置 */
        }
    }

    /* 优雅关闭资源 */
    close(sfd);
    return 0;
}