更新緩存而不會阻止

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而不是cache_的unique_ptr。當所有線程都完成cache_時，shared_ptr應該刪除它自己。

有關我的程序：我的程序是一個網絡服務器，將使用這些信息來決定返回什麼信息。這是相當高的吞吐量（數千次請求/秒）每個請求查詢緩存一次，所以告訴我的其他線程何時更新沒有問題。我可以容忍稍微過時的信息，並希望在可能的情況下阻止我的所有線程執行。緩存中的信息相當大，因此我想限制任何有價值的副本。

update_cache只運行一次。它運行在只監聽更新命令並運行代碼的線程中。

Answer 1

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_); 
} 

Answer 2

我覺得有多個問題：

1）不要泄漏內存：爲從未在代碼中使用「刪除」並用的unique_ptr（或shared_ptr的在特定情況下）

2棒）保護訪問共享數據，對於任一使用的鎖定（互斥）或無鎖mecanism（標準::原子）

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的內容。

總體可以保持低時延（一切都是相對的，我不知道你的使用情況），如果你照顧好做昂貴的操作（比如內存分配）的鎖定部分之外。