How to create thread safe cache of shared_ptr - c++

Question

I have a code that reads a lot of files. Some files can be cached. Consumer receives shared_ptr when asks for a file. Other consumers can ask for this file and get it from the cache if file is still in memory. If file is not in memory, it will be loaded and put in to the cache.
Simplified code:
struct File
{
File(std::string);
bool AllowCache() const;
};
typedef std::shared_ptr<File> SharedPtr;
typedef std::weak_ptr<File> WeakPtr;
std::map<std::string, WeakPtr> Cache;
SharedPtr GetFile(std::wstring Name)
{
auto Found = Cache.find(Name);
if (Found != Cache.end())
if (auto Exist = Found->second.lock())
return Exist;
auto New = boost::make_shared<File>(Name);
if (New->AllowCache())
Cache[Name] = New;
return New;
}
My question is: how to make this code thead safe? Even if I protect content of GetFile() by a mutex, it still can return non-null pointer from weak_ptr::lock() while other thread is running destructor of pointed File object.
I see some solutions, like:
Store shared_ptrs in the cache and run a separate thread that will
continuously remove shared_ptr-s with use_count()==1 (let's call it Cleanup()).
Store shared_ptrs in the cache and require consumers to use special wrapper of shared_ptr<File>. This wrapper will have shared_ptr<File> as a member and will reset() it at destructor and then call Cleanup().
1st solution is a bit ofoverkill. 2nd solution require to refactor all the code in my project. Both solutions are bad for me. Is any other way to make it thead safe?

Answer 1

Unless I'm misunderstanding the scenario you've described, A lock() of a WeakPtr will fail (i.e. return a dummy shared_ptr) if another thread is running a destructor of the File object. That's the logic of shared and weak pointers. So - your current solution should be thread safe in this respect; but - it may be non-thread-safe as you add or remove elemnrs. Read about that, say, in this question: C++ Thread-Safe Map .

Answer 2

I expected the following code will fail. But it's not. It seems like weak_ptr::lock() will not return pointer to an object that is in destruction process. And if so, it is a simpliest solution to just add a mutex and don't worry about returning dead objects by weak_ptr::lock().
char const *TestPath = "file.xml";
void Log(char const *Message, std::string const &Name, void const *File)
{
std::cout << Message
<< ": " << Name
<< " at memory=" << File
<< ", thread=" << std::this_thread::get_id()
<< std::endl;
}
void Sleep(int Seconds)
{
std::this_thread::sleep_for(std::chrono::seconds(Seconds));
}
struct File
{
File(std::string Name) : Name(Name)
{
Log("created", Name, this);
}
~File()
{
Log("destroying", Name, this);
Sleep(5);
Log("destroyed", Name, this);
}
std::string Name;
};
std::map<std::string, std::weak_ptr<File>> Cache;
std::mutex Mutex;
std::shared_ptr<File> GetFile(std::string Name)
{
std::unique_lock<std::mutex> Lock(Mutex); // locking is added
auto Found = Cache.find(Name);
if (Found != Cache.end())
if (auto Exist = Found->second.lock())
{
Log("found in cache", Name, Exist.get());
return Exist;
}
auto New = std::make_shared<File>(Name);
Cache[Name] = New;
return New;
}
void Thread2()
{
auto File = GetFile(TestPath);
//Sleep(3); // uncomment to share file with main thead
}
int main()
{
std::thread thread(&Thread2);
Sleep(1);
auto File = GetFile(TestPath);
thread.join();
return 0;
}
My expectation:
thread2: created
thread2: destroying
thread1: found in cache <--- fail. dead object :(
thread2: destroyed
VS2017 results:
thread2: created
thread2: destroying
thread1: created <--- old object is not re-used! great ;)
thread2: destroyed