C++14中如何安全访问vector引用？单例类线程安全优化咨询

问题背景 #

我有一个用单例模式管理vector数据的DataManager类，代码如下：

class DataManager
{
public:
    static DataManager& GetInstance() {
        static DataManager instance;
        return instance;
    }
    const vector<int>& GetData() const{return data;}
    void SetData(vector<int>& data_)
    {
        data.swap(data_);
    }
private:
    vector<int> data;
};

需要在线程中访问并修改该数据，但访问时若数据被修改/释放会导致程序报错。我尝试了将锁作为参数传递的方案：

class DataManager
{
public:
    const std::vector<int>& GetRects(std::unique_lock<std::mutex>& lock) const
    {
        lock = std::unique_lock<std::mutex>(m_mutex_data);
        return data;
    }
// 省略其他成员
private:
    mutable std::mutex m_mutex_data;
};

该方案能运行，但感觉设计不合理，想知道有没有更优的实现方式？

优化方案 #

原方案的核心问题是把锁的生命周期管理暴露给外部调用者，极易出现误用——比如调用者提前解锁、锁作用域超出预期，导致返回的vector引用在无锁保护下被访问，依然存在线程安全风险。以下是几种更合理的实现方式：

1. 返回数据拷贝（简单直接） #

直接返回vector的拷贝，内部用std::lock_guard保证拷贝过程的线程安全，调用者无需关心锁的管理。缺点是数据量大时会有性能开销，适合数据规模较小的场景：

class DataManager
{
public:
    static DataManager& GetInstance() {
        static DataManager instance;
        return instance;
    }

    std::vector<int> GetData() const
    {
        std::lock_guard<std::mutex> lock(m_mutex_data);
        return data;
    }

    void SetData(std::vector<int> data_)
    {
        std::lock_guard<std::mutex> lock(m_mutex_data);
        data.swap(data_);
    }

private:
    mutable std::mutex m_mutex_data;
    std::vector<int> data;
};

2. 提供访问回调（安全可控） #

将处理数据的逻辑封装成回调函数，在DataManager内部持有锁的情况下执行回调，确保数据访问全程处于锁保护中，彻底避免外部持有引用的风险：

#include <functional>

class DataManager
{
public:
    static DataManager& GetInstance() {
        static DataManager instance;
        return instance;
    }

    // 读操作回调：传入const引用，保证只读
    void AccessData(const std::function<void(const std::vector<int>&)>& callback) const
    {
        std::lock_guard<std::mutex> lock(m_mutex_data);
        callback(data);
    }

    // 写操作回调：传入非const引用，支持修改
    void ModifyData(const std::function<void(std::vector<int>&)>& callback)
    {
        std::lock_guard<std::mutex> lock(m_mutex_data);
        callback(data);
    }

private:
    mutable std::mutex m_mutex_data;
    std::vector<int> data;
};

使用示例：

// 读数据
DataManager::GetInstance().AccessData([](const std::vector<int>& data) {
    // 在这里安全处理数据，比如遍历、计算
    for (int num : data) {
        // ...
    }
});

// 修改数据
DataManager::GetInstance().ModifyData([](std::vector<int>& data) {
    data.push_back(100);
    data.erase(data.begin());
});

3. 读写分离锁（高并发场景） #

如果是C++17及以上版本，可以使用std::shared_mutex（读写锁），读操作使用std::shared_lock共享锁，允许多个线程同时读；写操作使用std::unique_lock独占锁，保证写操作的排他性，提升并发效率：

#include <shared_mutex>

class DataManager
{
public:
    static DataManager& GetInstance() {
        static DataManager instance;
        return instance;
    }

    const std::vector<int>& GetData() const
    {
        std::shared_lock<std::shared_mutex> lock(m_rw_mutex);
        return data;
    }

    void SetData(std::vector<int> data_)
    {
        std::unique_lock<std::shared_mutex> lock(m_rw_mutex);
        data.swap(data_);
    }

private:
    mutable std::shared_mutex m_rw_mutex;
    std::vector<int> data;
};

注意：这种方式返回的是const引用，调用者必须保证引用的使用全程处于shared_lock的作用域内（锁会阻止写操作，确保数据不会被修改）。如果需要长时间持有数据，建议优先使用拷贝或回调方式。

内容的提问来源于stack exchange，提问作者白镜明