Boost::interprocess::scoped_lock进程崩溃后无法获取问题排查求助

问题根因 #

你遇到的死锁是进程崩溃导致互斥锁永久占用导致的：

• boost::interprocess::interprocess_mutex底层使用非稳健POSIX互斥锁，当持有该锁的进程异常终止（如Ctrl+C强制杀死）时，内核不会自动释放锁，锁会永远处于"已持有"状态，所有后续尝试获取该锁的进程都会永久阻塞。
• 你复现的场景中，主进程1恰好是在持有mutex的阶段被强制终止，锁没有被释放；从进程2的超时等待逻辑返回后直接升级为主角色，没有处理已被异常占有的锁，新启动的实例3尝试加锁时就会直接卡住。

排查思路 #

1. 确认阻塞点：用gdb attach [卡住的进程PID]执行bt打印调用栈，可看到进程阻塞在pthread_mutex_lock系统调用上，直接定位是互斥锁未释放导致的死锁。
2. 校验锁状态：你可以写一个小程序读取/dev/shm/IPCTest共享内存段中mutex字段的状态，确认锁处于已持有状态且无存活进程持有该锁。
3. 替换锁逻辑验证：将所有阻塞加锁逻辑替换为超时加锁，如果超时触发即可确认是锁遗留问题。

解决方法 #

1. 替换为稳健互斥锁 #

将共享内存中的interprocess_mutex替换为boost::interprocess::interprocess_robust_mutex，该类型锁支持进程崩溃后恢复：

• 持有锁的进程崩溃后，下一个获取锁的进程会收到EOWNERDEAD错误
• 调用锁的consistent()方法即可将锁恢复到可用状态，之后可以正常使用

2. 增加锁异常恢复逻辑 #

在所有加锁的位置增加超时判断和锁恢复逻辑，示例修改如下：

// 首先修改shared_info中的mutex定义
struct shared_info {
private:
    interprocess_robust_mutex      mutex; // 替换为稳健互斥锁
    interprocess_condition  cv_primary;
    interprocess_condition  cv_secondary;
    int test{0};
    bool primary_request_pending{false};
    bool secondary_request_pending{false};
public:
    // 锁恢复公共函数，可复用
    bool try_lock_with_recovery(scoped_lock<interprocess_robust_mutex>& lock, int timeout_sec = 3) {
        if (lock.try_lock_for(boost::posix_time::seconds(timeout_sec))) {
            return true;
        }
        // 锁超时，检查是否是持有进程崩溃导致的
        if (mutex.check_sentinel() == interprocess_robust_mutex::owner_dead) {
            mutex.consistent(); // 修复锁状态
            // 重置所有共享状态变量，避免脏数据
            primary_request_pending = false;
            secondary_request_pending = false;
            return lock.try_lock_for(boost::posix_time::seconds(timeout_sec));
        }
        return false;
    }

    void primary_fn() {
        std::cout << "primary_fn" << test++ << std::endl;
        scoped_lock<interprocess_robust_mutex> lock(mutex, defer_lock);
        if (!try_lock_with_recovery(lock)) {
            // 锁获取失败可做降级或退出逻辑
            return;
        }
        cv_primary.wait(lock, [=] { return primary_request_pending; });
        primary_request_pending = false;
        secondary_request_pending = true;
        cv_secondary.notify_all();
    }

    bool secondary_fn() {
        std::cout << "secondary_fn" << test++ << std::endl;
        scoped_lock<interprocess_robust_mutex> lock(mutex, defer_lock);
        if (!try_lock_with_recovery(lock)) {
            return false; // 锁获取失败，直接触发升级逻辑
        }
        primary_request_pending = true;
        cv_primary.notify_all();
        std::cout << "secondary will wait now" << test++ << std::endl;
        if (cv_secondary.timed_wait(lock, 
                                boost::posix_time::microsec_clock::universal_time() + 
                                boost::posix_time::seconds(5),
                                [=] { return secondary_request_pending; })) {
            secondary_request_pending = false;
            return true;
        }
        else return false;
    }
};

3. 增加退出信号处理 #

为进程注册SIGINT、SIGTERM信号处理函数，收到退出信号时主动释放持有的锁，避免正常退出场景下的锁遗留问题。

4. 优化共享内存初始化逻辑 #

主进程创建共享内存前，先尝试删除已存在的同名共享内存，避免之前测试残留的脏数据影响：

// 在init函数创建共享内存前添加
shared_memory_object::remove(SHM_NAME);

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