C++多线程多读单写资源组管理的优质设计方案咨询

• 资源不共享，读写逻辑完全失效：每个Token实例都持有独立的Resource对象，WriteToken修改的是自己的私有实例，ReadToken读取的是另一个完全独立的实例，完全达不到多线程共享同一资源的目的，这是核心逻辑错误。
• 锁持有时间过长：WriteToken和ReadToken在构造时就获取锁，直到Token销毁才释放。如果Token创建后很久才调用Visit，或者Visitor执行耗时操作，锁会被长时间占用，严重降低并发性能。
• 资源重复加载与内存泄漏：每次创建Token都会重新"打开资源"，重复加载不仅浪费系统资源，还会导致数据不一致；同时TokenManager中的m_tokens容器没有清理机制，创建的shared_mutex会永远驻留内存，造成泄漏。
• 锁与资源脱节：TokenManager中的shared_mutex和资源完全分离，锁没有起到保护共享资源访问的作用，只是一个无意义的空锁。
• 缺乏资源生命周期管理：没有机制跟踪资源的使用情况，当某个资源不再被任何线程访问时，无法自动释放资源和对应的锁，持续占用系统资源。

正确的思路是：将共享资源与对应的读写锁绑定，通过管理器统一维护资源生命周期和锁访问，利用RAII机制确保锁的正确获取与释放，同时保证所有线程访问的是同一个资源实例。

核心实现示例 #

1. 资源与锁的绑定结构

#include <unordered_map>
#include <shared_mutex>
#include <memory>
#include <mutex>

struct Resource {
    // 资源数据成员示例
    int value = 0;
};

// 封装资源和对应的读写锁，确保锁与资源一一对应
struct ResourceEntry {
    std::shared_ptr<Resource> resource;
    std::shared_mutex rw_mutex;
};

2. 资源管理器实现

class ResourceManager {
private:
    std::mutex m_container_mutex; // 保护资源容器的互斥锁
    std::unordered_map<int, std::unique_ptr<ResourceEntry>> m_resources;

    // 线程安全的懒加载：首次访问时创建资源和锁
    ResourceEntry& get_entry(int key) {
        std::lock_guard<std::mutex> guard(m_container_mutex);
        auto it = m_resources.find(key);
        if (it == m_resources.end()) {
            auto entry = std::make_unique<ResourceEntry>();
            entry->resource = std::make_shared<Resource>();
            it = m_resources.emplace(key, std::move(entry)).first;
        }
        return *it->second;
    }

public:
    // 读访问RAII封装：自动管理读锁的获取与释放
    class ReadGuard {
    private:
        std::shared_lock<std::shared_mutex> m_lock;
        std::shared_ptr<Resource> m_resource;
    public:
        ReadGuard(ResourceEntry& entry) 
            : m_lock(entry.rw_mutex), m_resource(entry.resource) {}

        // 提供只读访问接口
        const Resource& get() const { return *m_resource; }
    };

    // 写访问RAII封装：自动管理写锁的获取与释放
    class WriteGuard {
    private:
        std::unique_lock<std::shared_mutex> m_lock;
        std::shared_ptr<Resource> m_resource;
    public:
        WriteGuard(ResourceEntry& entry) 
            : m_lock(entry.rw_mutex), m_resource(entry.resource) {}

        // 提供可写访问接口
        Resource& get() { return *m_resource; }
    };

    // 获取读权限
    ReadGuard acquire_read(int key) {
        return ReadGuard(get_entry(key));
    }

    // 获取写权限
    WriteGuard acquire_write(int key) {
        return WriteGuard(get_entry(key));
    }

    // 可选：清理无引用的资源（通过shared_ptr计数判断是否有外部访问）
    void cleanup_unused() {
        std::lock_guard<std::mutex> guard(m_container_mutex);
        for (auto it = m_resources.begin(); it != m_resources.end();) {
            if (it->second->resource.use_count() == 1) {
                it = m_resources.erase(it);
            } else {
                ++it;
            }
        }
    }
};

3. 使用示例

void read_resource(ResourceManager& manager, int key) {
    auto guard = manager.acquire_read(key);
    const Resource& res = guard.get();
    // 执行读操作
    printf("Read resource %d: %d\n", key, res.value);
}

void write_resource(ResourceManager& manager, int key, int new_value) {
    auto guard = manager.acquire_write(key);
    Resource& res = guard.get();
    res.value = new_value;
    // 执行写操作
    printf("Write resource %d: %d\n", key, res.value);
}

方案优势 #

• 真正的共享资源访问：所有线程通过Guard访问的是同一个Resource实例，读写操作的是同一数据。
• 锁的合理持有：锁的持有时间仅为实际访问资源的时间段，避免无意义的长时间占用。
• RAII自动管理锁：Guard析构时自动释放锁，无需手动操作，避免死锁风险。
• 资源生命周期可控：通过shared_ptr的引用计数跟踪资源使用情况，可实现自动清理。
• 线程安全的懒加载：首次访问资源时才创建，避免不必要的资源预加载。

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