在POSIX可靠信号机制应用于高并发服务时，避免竞态条件是确保程序正确性的关键。竞态条件是指多个进程或线程对共享资源的访问顺序不一致，导致程序结果依赖于执行的时序，从而引发数据不一致、程序崩溃或不可预测的行为。在高并发环境中，信号处理、信号屏蔽与恢复、以及等待信号等操作都可能成为竞态条件的源头。以下将结合具体的场景和代码示例，详细阐述避免竞态条件的策略。

一、核心竞态场景分析与规避

高并发服务中，与信号处理相关的典型竞态条件主要发生在信号处理函数的执行、信号屏蔽字的修改以及等待信号的时刻。下表总结了关键场景及对应的规避策略：

二、关键技术实现与代码示例

1. 使用 sigaction 并设置 sa_mask 以安全捕获信号

signal 函数因其不可靠性（如信号处理动作被复位、不支持阻塞其他信号）而不推荐用于高并发环境。应使用 sigaction 函数，并利用其 sa_mask 字段，在信号处理函数执行期间自动阻塞指定的信号集，防止嵌套中断。

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

void safe_signal_handler(int signo) {
    /* 此处理函数执行期间，sa_mask中指定的信号（如SIGUSR2）将被自动阻塞 */
    write(STDOUT_FILENO, "Signal caught safely.
", 22);
    /* 注意：此处使用write而非printf，因为printf不可重入 */
}

int install_safe_handler() {
    struct sigaction act, old_act;
    sigset_t block_mask;

    /* 初始化信号集，并添加希望在处理SIGUSR1时阻塞的信号 */
    sigemptyset(&block_mask);
    sigaddset(&block_mask, SIGUSR2); // 示例：阻塞SIGUSR2

    act.sa_handler = safe_signal_handler;
    act.sa_mask = block_mask; // 关键：设置执行处理函数时的附加阻塞信号集
    act.sa_flags = SA_RESTART; // 可选：使被此信号中断的系统调用自动重启

    if (sigaction(SIGUSR1, &act, &old_act) < 0) {
        perror("sigaction error");
        return -1;
    }
    return 0;
}

2. 使用 sigsuspend 原子性地等待信号

这是避免“解除屏蔽-等待”竞态的经典模式。sigsuspend 会临时将进程的信号屏蔽字替换为参数指定的信号集，并挂起进程，直到捕获到一个信号。这个“替换屏蔽字”和“挂起”是原子操作。

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

volatile sig_atomic_t quit_flag = 0; // 用于信号处理函数与主循环通信的标志

void sigint_handler(int signo) {
    quit_flag = 1;
}

int main() {
    struct sigaction act;
    sigset_t newmask, oldmask, zeromask;

    /* 安装信号处理函数 */
    act.sa_handler = sigint_handler;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    if (sigaction(SIGINT, &act, NULL) < 0) {
        perror("sigaction SIGINT error");
        return 1;
    }

    /* 设置阻塞SIGINT的信号屏蔽字 */
    sigemptyset(&newmask);
    sigaddset(&newmask, SIGINT);
    if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0) { // 阻塞SIGINT
        perror("SIG_BLOCK error");
        return 1;
    }

    /* 临界区：在此执行不希望被SIGINT中断的代码 */

    /* 安全地等待SIGINT：重置信号屏蔽字为空并挂起 */
    sigemptyset(&zeromask);
    while (quit_flag == 0) {
        // sigsuspend原子性地将进程信号屏蔽字设为zeromask，并挂起
        // 当SIGINT递送时，先执行处理函数，然后sigsuspend返回，恢复原来的屏蔽字(newmask)
        sigsuspend(&zeromask);
    }

    /* SIGINT已处理，恢复原来的信号屏蔽字 */
    if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0) {
        perror("SIG_SETMASK error");
        return 1;
    }

    printf("Program exiting gracefully.
");
    return 0;
}

3. 多线程环境下的信号处理策略

在多线程程序中，信号可以递送到任意线程，这引入了复杂性。最佳实践是：

• 统一信号处理线程：在主线程或某个专用线程中处理所有信号。
• 使用 pthread_sigmask 和 sigwait：阻塞所有信号在主线程，然后创建一个专用线程调用 sigwait 来同步等待并处理信号。

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

void* signal_thread(void* arg) {
    sigset_t wait_mask = *(sigset_t*)arg;
    int sig_caught;

    for (;;) {
        if (sigwait(&wait_mask, &sig_caught) != 0) { // 同步等待信号
            perror("sigwait failed");
            break;
        }
        switch (sig_caught) {
            case SIGTERM:
                printf("Signal thread: Received SIGTERM, initiating shutdown.
");
                /* 执行清理操作，并通知其他线程 */
                exit(EXIT_SUCCESS);
                break;
            case SIGUSR1:
                printf("Signal thread: Received SIGUSR1.
");
                /* 处理SIGUSR1 */
                break;
            default:
                printf("Signal thread: Received unexpected signal %d
", sig_caught);
        }
    }
    return NULL;
}

int main() {
    pthread_t tid;
    sigset_t block_mask;

    /* 在主线程中阻塞所有关心的信号 */
    sigemptyset(&block_mask);
    sigaddset(&block_mask, SIGTERM);
    sigaddset(&block_mask, SIGUSR1);
    if (pthread_sigmask(SIG_BLOCK, &block_mask, NULL) != 0) { // 设置线程信号屏蔽字
        perror("pthread_sigmask");
        return 1;
    }

    /* 创建专门处理信号的线程 */
    if (pthread_create(&tid, NULL, signal_thread, (void*)&block_mask) != 0) {
        perror("pthread_create");
        return 1;
    }

    /* 主线程继续执行其他任务，不会被异步信号中断 */
    printf("Main thread running. Send SIGTERM or SIGUSR1.
");
    /* ... 主业务逻辑 ... */

    pthread_join(tid, NULL);
    return 0;
}

三、结合其他同步机制

在高并发服务中，信号处理常常需要与线程间共享数据交互。此时，信号处理函数中设置标志，主循环或其他线程检查该标志是常见模式。为了安全地访问这些共享标志，需要结合互斥锁、读写锁或条件变量等同步原语。但需注意，信号处理函数中不能直接调用非异步信号安全的函数（如 pthread_mutex_lock），因为这可能导致死锁或未定义行为。替代方案是：

1. 使用 volatile sig_atomic_t 类型的标志进行简单通信。
2. 如果必须使用锁，可以考虑在信号处理函数中仅设置标志，在外部主循环中检查标志并获取锁进行操作。或者，使用 signalfd（Linux特有）将信号转换为文件描述符事件，从而集成到 select/poll/epoll 事件循环中，完全避免在信号处理函数中执行复杂操作。

四、总结与最佳实践

在高并发服务中安全使用POSIX可靠信号，避免竞态条件，应遵循以下核心原则：

1. 弃用 signal，采用 sigaction：利用 sa_mask 确保信号处理函数的原子性执行。
2. 用 sigsuspend 替代 pause：确保等待信号时，信号屏蔽字的修改与进程挂起是原子的。
3. 多线程环境显式管理信号：使用 pthread_sigmask 控制信号屏蔽，并考虑使用专用线程通过 sigwait 同步处理信号。
4. 保持信号处理函数简洁且可重入：仅执行异步信号安全的操作，使用 volatile sig_atomic_t 标志与主程序通信。
5. 区分可靠信号与不可靠信号：对于需要排队的场景，优先使用编号在 SIGRTMIN 至 SIGRTMAX 之间的可靠（实时）信号。
   通过将信号处理逻辑与并发控制机制（如锁、条件变量）谨慎结合，并严格遵循上述原子操作和同步原则，可以构建出健壮的高并发服务，有效规避由信号引发的竞态条件。

参考来源

• 《UNIX环境高级编程》读书笔记11: 信号
• 竞态条件
• Linux线程同步—竞态条件与互斥锁、读写锁(C语言)
• 【探索Linux】 P.22（POSIX信号量）
• C语言的竞态条件
• 信号机制详解：信号类型、信号处理、可靠信号与不可靠信号