实现持有std::mutex锁的RAII容器类，保障类实例独占访问

你的需求很清晰：通过RAII机制让GetClass返回实例时自动锁定对应ID的互斥量，确保同一ID的实例同一时间只能被一个线程持有，超出作用域自动解锁。我来帮你梳理下可行的方案，先分析下你之前尝试的问题，再给出完整实现。

为什么之前的方案效果不佳？ #

• 用std::pair<std::mutex, std::shared_ptr<MyClass>>存map：std::mutex不可拷贝，虽然C++11后map的操作支持移动，但最大的问题是没法把锁的生命周期和返回的shared_ptr绑定——你得手动加锁解锁，没法做到自动RAII管理，很容易出现锁未释放的情况。
• 封装ClassContainer：这个方向是对的，但直接返回容器的话，用户需要手动调用锁，没法实现"获取时自动锁定"的需求。我们需要给容器加一层RAII包装，让锁在对象构造时自动生效，析构时自动释放。

完整实现方案 #

1. 定义实例条目结构体 #

首先，我们需要给每个ID对应的实例和互斥量建一个绑定的结构体，这样每个ID的锁是独立的：

#include <map>
#include <mutex>
#include <memory>

struct InstanceEntry {
    std::mutex mtx;
    std::shared_ptr<MyClass> instance;
};

// 全局/类内的实例存储map
std::map<int, InstanceEntry> class_map;
// 保护map自身的互斥量（因为多个线程可能同时修改map）
std::mutex map_mtx;

2. 实现RAII锁包装类 #

我们需要一个包装类，它持有MyClass的智能指针和已锁定的互斥量，在构造时自动锁定，析构时自动解锁：

class LockedInstance {
public:
    // 构造函数：接收实例指针和已锁定的锁，通过移动语义转移所有权
    LockedInstance(std::shared_ptr<MyClass> inst, std::unique_lock<std::mutex> lock)
        : instance_(std::move(inst)), lock_(std::move(lock)) {}

    // 重载->运算符，让包装类可以像智能指针一样调用MyClass的成员
    MyClass* operator->() const {
        return instance_.get();
    }

    // 提供get方法获取原始指针（可选）
    MyClass* get() const {
        return instance_.get();
    }

private:
    std::shared_ptr<MyClass> instance_;
    std::unique_lock<std::mutex> lock_; // 用unique_lock支持移动，lock_guard不行
};

3. 实现线程安全的GetClass函数 #

这个函数负责：保护map的修改、确保实例存在、锁定对应互斥量、返回RAII包装对象：

LockedInstance GetClass(int id) {
    // 先锁定map，确保多线程下插入新条目是安全的
    std::lock_guard<std::mutex> map_lock(map_mtx);
    // 如果id不存在，map会自动构造一个InstanceEntry
    auto& entry = class_map[id];

    // 锁定当前实例的互斥量
    std::unique_lock<std::mutex> instance_lock(entry.mtx);

    // 懒加载实例：如果还没创建，就初始化
    if (!entry.instance) {
        entry.instance = std::make_shared<MyClass>();
    }

    // 返回包装对象，转移锁和实例的所有权
    return LockedInstance(entry.instance, std::move(instance_lock));
}

4. 示例用法 #

完全符合你想要的效果，无需手动加解锁：

void CallingFunction() {
    auto locked_inst = GetClass(1);
    // 此时ID为1的实例已经被锁定，其他线程调用GetClass(1)会阻塞
    locked_inst->SomeFunction(); // 直接调用MyClass的成员函数
} // locked_inst超出作用域，锁自动释放，实例的生命周期由shared_ptr管理

关键细节说明 #

• 为什么用unique_lock而不是lock_guard？：因为我们需要把锁从GetClass函数转移到返回的LockedInstance对象中，lock_guard不支持移动语义，而unique_lock支持，完美适配RAII的转移需求。
• map的线程安全：必须用额外的map_mtx保护map的修改，否则多线程同时插入新条目会导致未定义行为。
• 懒加载控制：如果你的MyClass初始化很耗时，当前的实现会让后续线程等待第一个线程完成初始化，这通常是合理的；如果需要避免等待，可以考虑双重检查锁（但要注意内存模型问题）。

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