使用互斥量等待退出信号是否合规？求更优方案及非信号场景验证

一、信号触发退出场景：你的方案存在的问题及替代方案 #

1. 当前方案的致命问题 #

• 死锁风险：如果用的是默认的PTHREAD_MUTEX_NORMAL互斥量，主线程第一次pthread_mutex_lock(&lock)成功后，第二次调用会直接阻塞（死锁），根本等不到信号处理函数的解锁操作。即便改用递归互斥量，信号处理函数里调用pthread_mutex_unlock也属于未定义行为——POSIX标准明确规定，pthread_mutex_*系列函数不是异步信号安全的，在信号处理函数中调用可能导致程序崩溃、死锁或其他不可预测的行为。

2. 更优的实现方案 #

方案1：条件变量+原子变量（推荐）

利用异步信号安全的pthread_cond_signal实现即时唤醒，结合原子变量标记退出状态：

#include <pthread.h>
#include <stdatomic.h>

atomic_bool exit_flag = ATOMIC_VAR_INIT(false);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

void signal_handler(int sig) {
    atomic_store(&exit_flag, true);
    // pthread_cond_signal是异步信号安全的，可在信号处理函数中调用
    pthread_cond_signal(&cond);
}

int main() {
    // 注册信号处理函数（示例：处理SIGTERM）
    signal(SIGTERM, signal_handler);

    pthread_mutex_lock(&mutex);
    while (!atomic_load(&exit_flag)) {
        // 挂起等待，直到收到唤醒信号
        pthread_cond_wait(&cond, &mutex);
    }
    pthread_mutex_unlock(&mutex);

    // 清理资源后退出
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    return 0;
}

• 优势：响应无延迟，不会像轮询那样浪费CPU或有1秒的等待间隙；完全符合POSIX标准，行为可预测。

方案2：sigsuspend直接挂起

让主线程主动挂起，直到收到目标信号，无需额外同步原语：

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

sig_atomic_t exit_flag = 0;

void signal_handler(int sig) {
    exit_flag = 1;
}

int main() {
    sigset_t mask, old_mask;
    sigemptyset(&mask);
    // 屏蔽目标退出信号（示例：SIGTERM）
    sigaddset(&mask, SIGTERM);

    // 注册信号处理函数
    signal(SIGTERM, signal_handler);

    // 阻塞目标信号，保存原有信号掩码
    sigprocmask(SIG_BLOCK, &mask, &old_mask);
    while (!exit_flag) {
        // 挂起线程，直到收到未屏蔽的信号
        sigsuspend(&old_mask);
    }
    // 恢复原有信号掩码
    sigprocmask(SIG_SETMASK, &old_mask, NULL);

    // 清理退出
    return 0;
}

• 优势：实现简单，无额外同步开销，响应即时。

二、JRPC等非信号触发场景：你的方案仍有问题及替代方案 #

1. 当前方案的问题 #

即便不用信号，主线程两次调用pthread_mutex_lock(&lock)依然会死锁（除非显式初始化递归互斥量）。就算改成递归锁，JRPC回调中重复调用pthread_mutex_unlock也会导致未定义行为（比如解锁未被当前线程持有的互斥量），逻辑上非常脆弱。

2. 更优的实现方案 #

方案1：条件变量+互斥量（通用可靠）

这是跨线程通知的标准实现，逻辑清晰且安全：

#include <pthread.h>

bool exit_flag = false;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

// JRPC退出回调函数
void jrpc_exit_callback() {
    pthread_mutex_lock(&mutex);
    exit_flag = true;
    pthread_cond_signal(&cond);
    pthread_mutex_unlock(&mutex);
}

int main() {
    // 注册JRPC回调（具体方式依JRPC框架而定）

    pthread_mutex_lock(&mutex);
    while (!exit_flag) {
        pthread_cond_wait(&cond, &mutex);
    }
    pthread_mutex_unlock(&mutex);

    // 清理资源后退出
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    return 0;
}

方案2：原子变量+轻量忙等（适合极端场景）

如果不想引入互斥量和条件变量，可使用原子变量，但忙等会占用CPU，仅适合短时间等待的场景：

#include <stdatomic.h>
#include <sched.h>

atomic_bool exit_flag = ATOMIC_VAR_INIT(false);

// JRPC退出回调函数
void jrpc_exit_callback() {
    atomic_store(&exit_flag, true);
}

int main() {
    // 注册JRPC回调

    while (!atomic_load(&exit_flag)) {
        // 让出CPU，减少忙等的资源消耗
        sched_yield();
    }

    // 清理退出
    return 0;
}

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