深度剖析：可重入锁（Recursive Lock / 递归锁）原理与实现

原创已于 2025-07-07 11:52:27 修改 · 726 阅读

20 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #服务器 #开发语言 #c++ #锁 #同步 #mutex

于 2025-07-07 11:50:26 首次发布

C/C++ 同时被 3 个专栏收录

368 篇文章

订阅专栏

Extension

328 篇文章

订阅专栏

Markdown

83 篇文章

订阅专栏

🔍 深度剖析：可重入锁（Recursive Lock）原理与实现

🧩 一、可重入锁核心概念

📌 1.1 问题背景

在多线程编程中，锁的嵌套调用是常见场景：

void funcA() {
    lock.lock();
    funcB(); // 内部也需获取同一把锁
    lock.unlock();
}

void funcB() {
    lock.lock();
    // ... 
    lock.unlock();
}

传统互斥锁（如std::mutex）会导致死锁——线程试图重复获取已持有的锁。

📌 1.2 可重入锁特性

同一线程可多次加锁（Reentrancy）
加锁/解锁次数必须匹配（Reentry Count）
不同线程互斥访问（Mutual Exclusion）

⚙️ 二、RecursiveSpinLock 实现剖析

📊 2.1 类结构图

🔄 2.2 核心工作流程

在这里插入图片描述

🔍 2.3 关键代码解析

(1) 锁获取逻辑

        template <class LockObject, class LockInternalObject, typename... TryEnterArguments>
        static constexpr bool RecursiveLock_TryEnter(LockObject&    lock, 
            LockInternalObject&                                     lock_internal, 
            std::atomic<int64_t>&                                   tid,
            std::atomic<int>&                                       reentries, 
            TryEnterArguments&&...                                  arguments)
        {
            int n = ++reentries;
            assert(n > 0);

            int64_t current_tid = GetCurrentThreadId(); /* std::hash<std::thread::id>{}(std::this_thread::get_id()); */
            if (n == 1)
            {
                bool lockTaken = lock_internal.TryEnter(std::forward<TryEnterArguments>(arguments)...);
                if (!lockTaken)
                {
                    reentries--;
                    return false;
                }

                tid.store(current_tid, std::memory_order_relaxed);
            }
            else
            {
                int64_t expected_tid = current_tid;
                if (!tid.compare_exchange_strong(expected_tid, current_tid, std::memory_order_relaxed, std::memory_order_relaxed))
                {
                    reentries--;
                    return false;
                }
            }

            return true;
        }

(2) 锁释放逻辑

        void RecursiveSpinLock::Leave()
        {
            int64_t current_tid = GetCurrentThreadId();
            int64_t expected_tid = current_tid;

            if (!tid_.compare_exchange_strong(expected_tid, current_tid, std::memory_order_relaxed, std::memory_order_relaxed))
            {
                throw std::runtime_error("Lock not owned by current thread.");
            }

            int n = --reentries_;
            if (n == 0)
            {
                tid_.store(0, std::memory_order_relaxed);
                lockobj_.Leave();
            }
            elif(n < 0)
            {
                throw std::runtime_error("Fail to release the atomic lock.");
            }
        }

(3) 死锁防御机制

~RecursiveSpinLock() noexcept(false) 
{
            if (reentries_ > 0) 
            {
                throw std::runtime_error("RecursiveSpinLock destroyed while held.");
            }
}

🌐 三、通用可重入锁实现范式

📜 3.1 标准实现模板

所有可重入锁均需三个核心组件：

底层锁（Lock Object）：提供基础互斥能力
持有者标识（Owner Identifier）：标记当前锁持有线程
重入计数器（Reentry Counter）：记录嵌套深度

在这里插入图片描述

⚖️ 3.2 多核CPU下的关键保障

内存可见性（Memory Visibility）

使用std::atomic确保跨核心数据同步

严格的内存序控制：

// 获取锁时的屏障
_.compare_exchange_strong(..., std::memory_order_acquire)

// 释放锁时的屏障
_.compare_exchange_strong(..., std::memory_order_release)

操作原子性（Atomicity）

重入计数修改必须原子化：

// 非原子操作会导致计数错乱
++reentries_; // 正确：std::atomic<int>

线程局部存储（Thread-Local State）
- 持有者ID必须与线程绑定：
```
int64_t current_tid = GetCurrentThreadId();
```

🔧 四、基于 std::mutex 的可重入锁实现

🛠️ 4.1 工作原理

🛠️ 4.2 代码实现

#include <mutex>
#include <condition_variable>
#include <thread>
#include <stdexcept>

class RecursiveMutex {
public:
    void lock() {
        std::thread::id this_id = std::this_thread::get_id();
        {
            std::unique_lock<std::mutex> lock(meta_mutex_);
            
            // 重入分支：当前线程已持有锁
            if (owner_ == this_id) {
                ++reentry_count_;
                return;
            }
            
            // 非持有线程等待
            while (owner_ != std::thread::id()) {
                cond_var_.wait(lock);
            }
            
            // 获取锁
            owner_ = this_id;
            reentry_count_ = 1;
        } // 自动释放meta_mutex_
    }

    void unlock() {
        std::unique_lock<std::mutex> lock(meta_mutex_);
        
        if (owner_ != std::this_thread::get_id()) {
            throw std::logic_error("非持有线程解锁");
        }
        
        if (--reentry_count_ == 0) {
            owner_ = std::thread::id(); // 重置持有者
            lock.unlock(); // 提前释放meta_mutex_
            cond_var_.notify_all(); // 唤醒所有等待线程
        }
    }

private:
    std::mutex meta_mutex_;
    std::condition_variable cond_var_;
    std::thread::id owner_;
    unsigned int reentry_count_ = 0;
};

🧩 多核CPU下的关键保障

内存可见性模型

多核心处理流程

跨核心同步机制

std::mutex：自带内存屏障，确保操作原子性
std::condition_variable：基于futex实现，支持跨核唤醒
std::thread::id：保证线程ID的跨核一致性

🧪 五、可重入锁的测试方法论

🔬 5.1 必须覆盖的测试场景

基础功能测试

// 单线程重入
recursive_mutex.lock();
recursive_mutex.lock(); // 应成功
recursive_mutex.unlock();
recursive_mutex.unlock();

线程安全测试

// 多线程竞争
std::vector<std::thread> threads;
for (int i=0; i<10; ++i) {
    threads.emplace_back([]{
        recursive_mutex.lock();
        // 临界区操作
        recursive_mutex.unlock();
    });
}

异常场景测试

// 过度解锁检测
TEST(RecursiveLockTest, OverUnlock) {
    RecursiveMutex mtx;
    EXPECT_THROW({
        mtx.lock();
        mtx.unlock();
        mtx.unlock(); // 应抛出异常
    }, std::logic_error);
}

🚀 六、工程实践建议

优先选择标准库

// C++标准库已提供优化实现
#include <mutex>
std::recursive_mutex safe_lock;

避免锁嵌套

// 重构前：两层嵌套
void process() {
    lock.lock();
    updateCache(); // 内部有锁
    lock.unlock();
}

// 重构后：扁平化锁
void process() {
    std::lock_guard guard(lock); 
    updateCache(); // 无锁版本
}