如何安全使用sem_destroy？避免销毁存在阻塞线程/进程的信号量

要安全调用sem_destroy，核心就是确保没有任何线程或进程正阻塞在该信号量的sem_wait调用上，下面是几个落地的实践方法：

1. 明确生命周期，等所有使用者退出后再销毁 #

这是最直接且可靠的方式。提前规划信号量的销毁时机，确保所有依赖它的线程/进程都已完成操作并退出，再执行销毁。

线程场景示例： #

#include <pthread.h>
#include <semaphore.h>
#include <stdbool.h>
#include <errno.h>

sem_t my_sem;
bool g_shutdown = false;
pthread_mutex_t shutdown_mutex = PTHREAD_MUTEX_INITIALIZER;

void* worker_thread(void* arg) {
    while (true) {
        // 先检查退出标志，避免进入sem_wait
        pthread_mutex_lock(&shutdown_mutex);
        bool should_exit = g_shutdown;
        pthread_mutex_unlock(&shutdown_mutex);
        if (should_exit) break;

        // 处理sem_wait被信号中断的情况（EINTR）
        int ret;
        do {
            ret = sem_wait(&my_sem);
        } while (ret == -1 && errno == EINTR);

        if (ret == -1) {
            // 处理错误，直接退出线程
            break;
        }

        // 执行信号量保护的业务逻辑...
        // 完成后记得释放信号量（如果是同步逻辑需要的话）
        sem_post(&my_sem);
    }
    return NULL;
}

int main() {
    // 初始化线程内使用的无名信号量（pshared=0）
    sem_init(&my_sem, 0, 1);

    pthread_t t1, t2;
    pthread_create(&t1, NULL, worker_thread, NULL);
    pthread_create(&t2, NULL, worker_thread, NULL);

    // 触发 shutdown 流程
    pthread_mutex_lock(&shutdown_mutex);
    g_shutdown = true;
    pthread_mutex_unlock(&shutdown_mutex);
    // 唤醒所有可能阻塞在sem_wait的线程
    sem_post(&my_sem);
    sem_post(&my_sem);

    // 等待所有线程完全退出
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    // 此时无任何线程等待信号量，可安全销毁
    sem_destroy(&my_sem);
    return 0;
}

2. 用计数跟踪等待状态，确保销毁时无阻塞 #

如果无法提前等待所有线程退出，可以维护一个等待计数，配合互斥锁和条件变量，确保调用sem_destroy时没有线程在等待信号量。

封装安全调用示例： #

#include <pthread.h>
#include <semaphore.h>
#include <errno.h>

sem_t my_sem;
pthread_mutex_t wait_count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t wait_count_zero = PTHREAD_COND_INITIALIZER;
int g_wait_count = 0;

// 封装sem_wait，自动跟踪等待计数
int safe_sem_wait(sem_t* sem) {
    pthread_mutex_lock(&wait_count_mutex);
    g_wait_count++;
    pthread_mutex_unlock(&wait_count_mutex);

    int ret;
    do {
        ret = sem_wait(sem);
    } while (ret == -1 && errno == EINTR);

    pthread_mutex_lock(&wait_count_mutex);
    g_wait_count--;
    // 计数归零时，通知等待销毁的线程
    if (g_wait_count == 0) {
        pthread_cond_signal(&wait_count_zero);
    }
    pthread_mutex_unlock(&wait_count_mutex);

    return ret;
}

// 安全销毁信号量的函数
int safe_sem_destroy(sem_t* sem) {
    pthread_mutex_lock(&wait_count_mutex);
    // 等待直到没有线程在等待信号量
    while (g_wait_count > 0) {
        pthread_cond_wait(&wait_count_zero, &wait_count_mutex);
    }
    pthread_mutex_unlock(&wait_count_mutex);

    // 此时可安全销毁
    return sem_destroy(sem);
}

3. 进程间使用无名信号量的特殊处理 #

如果无名信号量放在共享内存中供多进程使用，需要额外的跨进程同步机制：

• 在共享内存中设置全局退出标志，每个进程定期检查，收到标志后停止调用sem_wait；
• 用另一个同步信号量或共享计数，让主进程确认所有子进程都已停止访问目标信号量；
• 主进程确认后，再销毁信号量并释放共享内存。

关键注意事项 #

• 永远不要在信号处理函数中调用sem_destroy，它不是异步信号安全的函数；
• 信号量销毁后，不能再调用sem_wait/sem_post，除非重新用sem_init初始化；
• 一定要处理sem_wait返回的EINTR错误，避免线程因信号中断而卡在错误状态，导致无法退出。

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