进程终止后pthread_cond_t与pthread_mutex_t同步死锁问题求解

你遇到的死锁问题主要来源于以下几个逻辑缺陷：

1. 共享内存对象重复初始化

你将Poller结构体存放在共享内存中，当进程A崩溃重启后，大概率会重新在共享内存地址上执行Poller构造函数，直接覆盖正在被进程B使用的pthread_mutex_t、pthread_cond_t以及waiting变量的原有状态。此时进程B持有的同步原语已经被篡改，调用pthread_cond_broadcast时会直接进入未定义行为，表现为永久阻塞。

2. 错误处理覆盖不全

你仅处理了pthread_mutex_lock返回EOWNERDEAD的情况，但没有处理其他异常返回值（比如ENOTRECOVERABLE代表锁已经不可恢复，EINVAL代表锁结构被破坏），同时pthread_cond_wait的返回值完全没有校验，当等待过程中出现锁状态异常时无法感知。

3. 原子变量跨进程兼容性问题

std::atomic<bool>不保证进程间共享可见性，也不保证所有平台下都是无锁实现，如果你的编译器或者架构下std::atomic<bool>内部用到了进程内的同步原语，那么waiting变量的修改在另一个进程中完全看不到，会导致条件判断永远不成立。

• 新增共享内存初始化校验逻辑
  在Poller结构体开头新增魔数字段，仅当第一次创建共享内存时执行构造初始化逻辑，后续进程附加共享内存时，先校验魔数是否合法，合法则直接复用原有对象，不再执行初始化，避免覆盖同步原语状态。
• 完善全链路错误处理
  所有pthread同步接口的返回值都要做校验，新增ENOTRECOVERABLE异常处理逻辑，触发时直接重置整个共享内存的同步状态。
• 替换跨进程原子变量
  要么确认std::atomic<bool>::is_always_lock_free为true，要么直接改用C11的_Atomic uint8_t或者手动加内存屏障保证跨进程可见性。
• 可选替代方案：改用POSIX进程间信号量
  如果对鲁棒性要求极高，建议放弃进程间条件变量方案，改用sem_t实现同步，信号量天生对进程崩溃场景友好，不存在状态不一致的问题，实现逻辑更简单。

#include <pthread.h>
#include <atomic>
#include <stdexcept>
#include <string>

// 魔数，用于判断共享内存是否已经初始化
constexpr uint32_t POLLER_MAGIC = 0x12345678;

struct Poller
{
private:
    uint32_t magic;
    // 确认是无锁原子变量再用，否则替换为C11 _Atomic uint8_t
    std::atomic<bool> waiting;
    pthread_mutex_t mtx;
    pthread_cond_t cnd;

    auto lockMutex() -> void
    {
        int ret = pthread_mutex_lock(&mtx);
        if (ret == EOWNERDEAD) {
            if (pthread_mutex_consistent(&mtx) != 0) {
                // 锁不可恢复，上层需要捕获异常重置共享内存
                throw std::runtime_error("Mutex recover failed");
            }
        } else if (ret == ENOTRECOVERABLE) {
            throw std::runtime_error("Mutex is unrecoverable");
        } else if (ret != 0) {
            throw std::runtime_error("Mutex lock failed, err: " + std::to_string(ret));
        }
    }

public:
    // 仅第一次创建共享内存时调用构造函数
    Poller()
    {
        magic = POLLER_MAGIC;
        waiting = false;
        
        pthread_mutexattr_t attr;
        pthread_mutexattr_init(&attr);
        pthread_mutexattr_setrobust(&attr, PTHREAD_MUTEX_ROBUST);
        pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
        pthread_mutex_init(&mtx, &attr);
        pthread_mutexattr_destroy(&attr);

        pthread_condattr_t attrcond;
        pthread_condattr_init(&attrcond);
        pthread_condattr_setpshared(&attrcond, PTHREAD_PROCESS_SHARED);
        pthread_cond_init(&cnd, &attrcond);
        pthread_condattr_destroy(&attrcond);
    }

    // 附加共享内存时调用，判断是否已经初始化
    auto isInitialized() -> bool
    {
        return magic == POLLER_MAGIC;
    }

    auto wait() -> void
    { 
        lockMutex();
        waiting = true;
        while(waiting) {
            int ret = pthread_cond_wait(&cnd, &mtx);
            if (ret == EOWNERDEAD) {
                if (pthread_mutex_consistent(&mtx) != 0) {
                    pthread_mutex_unlock(&mtx);
                    throw std::runtime_error("Cond wait mutex recover failed");
                }
            } else if (ret != 0) {
                pthread_mutex_unlock(&mtx);
                throw std::runtime_error("Cond wait failed, err: " + std::to_string(ret));
            }
        }
        pthread_mutex_unlock(&mtx);
    }

    auto notify() -> void
    {    
        lockMutex();
        waiting = false;
        int ret = pthread_cond_broadcast(&cnd);
        if (ret != 0) {
            pthread_mutex_unlock(&mtx);
            throw std::runtime_error("Cond broadcast failed, err: " + std::to_string(ret));
        }
        pthread_mutex_unlock(&mtx);
    }
};

使用注意：进程重启映射共享内存后，先将地址转换为Poller*，调用isInitialized()判断是否已经初始化，只有第一次创建时调用placement new执行构造函数，其他情况直接使用即可。

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