如何让线程重复锁定同一mutex时触发程序崩溃而非死锁？

你可以通过封装std::mutex实现自定义互斥锁类来满足需求，既规避继承标准库类的不良实践，也不依赖私有实现细节，同时能在同一线程重复加锁时直接触发崩溃。

核心实现思路 #

自定义互斥锁类内部持有std::mutex作为底层锁，同时用原子变量跟踪锁的持有计数，以及当前持有锁的线程ID。每次调用lock()时先检查当前线程是否已持有该锁，若是则直接触发崩溃；否则正常加锁并更新持有信息。

代码示例 #

#include <mutex>
#include <thread>
#include <atomic>
#include <cstdlib>

class CheckedMutex {
private:
    std::mutex m_inner_mutex;
    std::thread::id m_owner_thread;
    std::atomic<int> m_lock_count{0};

public:
    void lock() {
        const auto current_id = std::this_thread::get_id();
        // 检查当前线程是否已持有锁
        if (m_lock_count.load(std::memory_order_acquire) > 0 && m_owner_thread == current_id) {
            // 触发崩溃，可根据需求替换为assert或其他崩溃逻辑
            std::abort();
        }
        // 正常加锁底层mutex
        m_inner_mutex.lock();
        // 更新持有信息
        m_owner_thread = current_id;
        m_lock_count.fetch_add(1, std::memory_order_release);
    }

    void unlock() {
        const auto current_id = std::this_thread::get_id();
        // 检查解锁合法性：当前线程是否持有锁
        if (m_lock_count.load(std::memory_order_acquire) == 0 || m_owner_thread != current_id) {
            std::abort();
        }
        // 更新计数，若计数归0则重置owner
        if (m_lock_count.fetch_sub(1, std::memory_order_release) == 1) {
            m_owner_thread = std::thread::id();
        }
        // 解锁底层mutex
        m_inner_mutex.unlock();
    }

    bool try_lock() {
        const auto current_id = std::this_thread::get_id();
        if (m_lock_count.load(std::memory_order_acquire) > 0 && m_owner_thread == current_id) {
            std::abort();
        }
        if (m_inner_mutex.try_lock()) {
            m_owner_thread = current_id;
            m_lock_count.fetch_add(1, std::memory_order_release);
            return true;
        }
        return false;
    }
};

方案优势 #

• 完全遵循标准库使用规范：通过封装而非继承std::mutex，避免了继承标准库类的风险，也不依赖任何私有实现细节；
• 用法与std::mutex一致：可以直接替换代码中的std::mutex，无需修改原有锁的使用逻辑；
• 严格的运行时检查：不仅能检测同一线程重复加锁的情况，还能检查非法解锁（比如未持有锁的线程调用unlock()），提升代码健壮性；
• 满足需求：直接触发崩溃而非死锁，帮助快速定位递归加锁的逻辑问题。

补充说明 #

• 若仅在Debug模式下需要该检查，可将std::abort()替换为assert(false)，Release模式下断言会被自动禁用；
• 原子变量的内存序选择（memory_order_acquire/memory_order_release）确保了多线程环境下持有信息的可见性，避免竞态条件。

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