信号机制¶

#include <signal.h>
int kill(pid_t pid, int sig);

if (kill(pid, 0) == -1 && errno == ESRCH) {
    /* 进程不存在 */
}

#include <signal.h>
int raise(int sig);

#include <unistd.h>
unsigned int alarm(unsigned int seconds);

/* 为某个操作设置超时 */
alarm(5);           /* 5 秒后触发 SIGALRM */
slow_operation();   /* 如果 5 秒内没完成，会被 SIGALRM 打断 */
alarm(0);           /* 操作完成，取消定时器 */

#include <signal.h>
typedef void (*sighandler_t)(int);
sighandler_t signal(int sig, sighandler_t handler);

void sigint_handler(int sig) {
    /* 注意：这里不能调用 printf！后文会解释原因 */
    write(STDOUT_FILENO, "收到 SIGINT\n", 13);
}

int main(void) {
    signal(SIGINT, sigint_handler);   /* 安装处理器 */
    signal(SIGPIPE, SIG_IGN);         /* 忽略 SIGPIPE */
    /* ... */
}

#include <signal.h>
int sigaction(int sig, const struct sigaction *act,
              struct sigaction *oldact);

struct sigaction {
    void     (*sa_handler)(int);          /* 处理器函数，或 SIG_DFL/SIG_IGN */
    sigset_t   sa_mask;                   /* 处理器执行期间额外阻塞的信号集 */
    int        sa_flags;                  /* 选项标志 */
    void     (*sa_sigaction)(int, siginfo_t *, void *); /* 带额外信息的处理器 */
};

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

void handler(int sig) {
    const char msg[] = "收到信号\n";
    write(STDOUT_FILENO, msg, sizeof(msg) - 1); /* 异步安全 */
}

int main(void) {
    struct sigaction sa;
    sigemptyset(&sa.sa_mask);          /* 初始化为空信号集 */
    sigaddset(&sa.sa_mask, SIGTERM);   /* 处理器执行时额外阻塞 SIGTERM */
    sa.sa_flags = SA_RESTART;          /* 被信号中断的系统调用自动重启 */
    sa.sa_handler = handler;

    if (sigaction(SIGINT, &sa, NULL) == -1) {
        /* 错误处理 */
    }
    pause(); /* 等待信号 */
    return 0;
}

#include <signal.h>
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

sigset_t block_set, old_mask;
sigemptyset(&block_set);
sigaddset(&block_set, SIGINT);
sigaddset(&block_set, SIGTERM);

/* 阻塞 SIGINT 和 SIGTERM，保存旧掩码 */
sigprocmask(SIG_BLOCK, &block_set, &old_mask);

/* 临界区：在此期间信号不会被投递 */
critical_section();

/* 恢复原有掩码，此时挂起的信号会被投递 */
sigprocmask(SIG_SETMASK, &old_mask, NULL);

sigset_t pending_set;
sigpending(&pending_set);

if (sigismember(&pending_set, SIGINT)) {
    /* SIGINT 当前处于未决状态（被阻塞，等待投递） */
}

sigset_t set;
sigemptyset(&set);           /* 初始化为空集 */
sigfillset(&set);            /* 初始化为全集（包含所有信号） */
sigaddset(&set, SIGINT);     /* 向集合中加入 SIGINT */
sigdelset(&set, SIGINT);     /* 从集合中移除 SIGINT */
sigismember(&set, SIGINT);   /* 检查 SIGINT 是否在集合中，返回 1/0 */

#include <unistd.h>
int pause(void); /* 始终返回 -1，errno = EINTR */

/* ❌ 危险：SIGTERM 可能在解除阻塞后、pause() 之前到达 */
sigprocmask(SIG_UNBLOCK, &block_set, NULL); /* 解除阻塞 */
pause();                                     /* 等待信号 — 信号可能已经错过了！ */

#include <signal.h>
int sigsuspend(const sigset_t *mask); /* 始终返回 -1，errno = EINTR */

sigset_t block_mask, wait_mask;
sigemptyset(&block_mask);
sigaddset(&block_mask, SIGTERM);

/* 阻塞 SIGTERM，防止在准备阶段被打断 */
sigprocmask(SIG_BLOCK, &block_mask, NULL);

/* 做一些准备工作... */

/* 构造等待时的掩码：允许 SIGTERM 投递 */
sigemptyset(&wait_mask); /* 空掩码 = 不额外阻塞任何信号 */

/* 原子性地：解除对 SIGTERM 的阻塞 + 挂起等待
   信号到达并处理完毕后，sigsuspend 返回，
   同时自动恢复调用前的掩码（block_mask）*/
sigsuspend(&wait_mask);

#include <sys/wait.h>
#include <signal.h>
#include <errno.h>

void sigchld_handler(int sig) {
    int status;
    pid_t child_pid;
    int saved_errno = errno; /* 保存 errno，信号处理器可能破坏它 */

    /* WNOHANG：不阻塞，立即返回；-1：等待任意子进程 */
    while ((child_pid = waitpid(-1, &status, WNOHANG)) > 0) {
        if (WIFEXITED(status)) {
            /* 子进程正常退出，退出码为 WEXITSTATUS(status) */
        } else if (WIFSIGNALED(status)) {
            /* 子进程被信号杀死，信号编号为 WTERMSIG(status) */
        }
    }

    errno = saved_errno; /* 恢复 errno */
}

/* 安装处理器 */
struct sigaction sa;
sa.sa_handler = sigchld_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART | SA_NOCLDSTOP; /* 不关心子进程停止，只关心退出 */
sigaction(SIGCHLD, &sa, NULL);

#include <signal.h>
int sigqueue(pid_t pid, int sig, const union sigval value);

union sigval {
    int   sival_int;  /* 整数数据 */
    void *sival_ptr;  /* 指针数据（仅在同进程内有意义） */
};

void rt_handler(int sig, siginfo_t *info, void *ucontext) {
    /* info->si_value.sival_int 是发送方传来的整数 */
    int data = info->si_value.sival_int;
}

struct sigaction sa;
sa.sa_sigaction = rt_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_SIGINFO;  /* 使用三参数处理器 */
sigaction(SIGRTMIN, &sa, NULL);

static volatile sig_atomic_t reload_config = 0;

void sighup_handler(int sig) {
    reload_config = 1;
}

/* 主循环 */
while (running) {
    if (reload_config) {
        reload_config = 0;
        load_config("/etc/myapp/config.conf"); /* 安全：在主循环中执行 */
    }
    /* 正常服务逻辑... */
}