不阻塞地更新缓存

Question

我目前有一个具有类似缓存机制的程序。我有一个线程正在侦听从另一台服务器到此缓存的更新。该线程将在收到更新时更新缓存。这是一些伪代码：

void cache::update_cache()
{
    cache_ = new std::map<std::string, value>();
    while(true)
    {
        if(recv().compare("update") == 0)
        {
            std::map<std::string, value> *new_info = new std::map<std::string, value>();
            std::map<std::string, value> *tmp;
            //Get new info, store in new_info
            tmp = cache_;
            cache_ = new_cache;
            delete tmp;              
        }
    }
}

std::map<std::string, value> *cache::get_cache()
{
    return cache_;
}

cache_ 正在同时从许多不同的线程中读取。我相信如果我的一个线程调用get_cache()，然后我的缓存更新，然后线程尝试访问存储的缓存，我将在这里遇到未定义的行为。

我正在寻找一种方法来避免这个问题。我知道我可以使用互斥体，但我不想阻止读取发生，因为它们必须尽可能低延迟，但如果需要，我可以走这条路。

我想知道这对于 unique_ptr 是否是一个很好的用例。我的理解是否正确，如果一个线程调用 get_cache，并且返回一个 unique_ptr 而不是标准指针，一旦所有具有旧版本缓存的线程都用它完成（即离开范围），该对象将被删除。

对于这种情况，使用 unique_ptr 是最佳选择，还是我没有想到的其他选择？

我们将不胜感激。

编辑：

我相信我在我的 OP 中犯了一个错误。我的意思是使用和传递一个 shared_ptr 而不是一个 unique_ptr 用于 cache_。当所有线程都使用 cache_ 完成时，shared_ptr 应该自行删除。

关于我的程序的一点点：我的程序是一个网络服务器，它将使用这些信息来决定返回什么信息。这是相当高的吞吐量（数千个请求/秒）每个请求都会查询一次缓存，因此告诉我的其他线程何时更新是没有问题的。我可以容忍稍微过时的信息，并且如果可能的话，我更愿意阻止我的所有线程执行。缓存中的信息相当大，因此我想限制任何副本的值。

update_cache 只运行一次。它在只监听更新命令并运行代码的线程中运行。

Answer 1

我觉得有多个问题：

1) 不要泄漏内存：因为永远不要在您的代码中使用“delete”并坚持使用 unique_ptr（或在特定情况下为 shared_ptr）

2) 使用锁定（互斥）或无锁机制（std::atomic）保护对共享数据的访问

class Cache {
    using Map = std::map<std::string, value>();
    std::unique_ptr<Map> m_cache;
    std::mutex m_cacheLock;
public:

    void update_cache()
    {
        while(true)
        {
            if(recv().compare("update") == 0)
            {
                std::unique_ptr<Map> new_info { new Map };
                //Get new info, store in new_info
                {
                   std::lock_guard<std::mutex> lock{m_cacheLock};
                   using std::swap;
                   swap(m_cache, new_cache);
                }
            }
        }
    }

注意：我不喜欢 update_cache() 成为缓存公共接口的一部分，因为它包含无限循环。我可能会用 recv 将循环外部化并有一个：

    void update_cache(std::unique_ptr<Map> new_info)
    {
        { // This inner brace is not useless, we don't need to keep the lock during deletion
           std::lock_guard<std::mutex> lock{m_cacheLock};
           using std::swap;
           swap(m_cache, new_cache);
        }
    }

现在为了读取缓存，使用适当的封装并且不要留下指向成员映射转义的指针：

    value get(const std::string &key)
    {
        // lock, fetch, and return. 
        // Depending on value type, you might want to allocate memory
        // before locking
    }

使用此签名，如果缓存中不存在该值，则必须抛出异常，另一种选择是返回类似 boost::optional 的内容。

总体而言，如果您在锁定部分之外进行昂贵的操作（例如内存分配），您可以保持低延迟（一切都是相对的，我不知道您的用例）。

Answer 2

shared_ptr 用于此目的非常合理，C++11 有a family of functions for handling shared_ptr atomically。如果数据在创建后是不可变的，您甚至不需要任何额外的同步：

class cache {
public:
    using map_t = std::map<std::string, value>;
    void update_cache();
    std::shared_ptr<const map_t> get_cache() const;
private:
    std::shared_ptr<const map_t> cache_;
};

void cache::update_cache()
{
    while(true)
    {
        if(recv() == "update")
        {
            auto new_info = std::make_shared<map_t>();
            // Get new info, store in new_info
            // Make immutable & publish
            std::atomic_store(&cache_,
                              std::shared_ptr<const map_t>{std::move(new_info)});
        }
    }
}

auto cache::get_cache() const -> std::shared_ptr<const map_t> {
    return std::atomic_load(&cache_);
}