Best way to sync access to shared resource

[pyretttt]

What is the best way in terms of drogon to make access to shared resources safe?
Let's consider following example

// main.cc
int some_shared_var;

drogon::app().getLoop()->runEvery(1s, []() {
   some_shared_var = std::rand();
});


// TestCtrl.cc
extern int some_shared_var;
void TestCtrl::asyncHandleHttpRequest(const HttpRequestPtr &req,
                                      std::function<void (const HttpResponsePtr &)> &&callback)
{
    auto resp=HttpResponse::newHttpResponse();
    resp->setBody(std::to_string(some_shared_var)); // Read here
    callback(resp);
}

As I understood threading model controller handler is called from arbitrary worker thread, hereof follows it must be completed with some synchronisation.

What is the best practices?
I suppose it's alright to move read to loop something like this.

// TestCtrl.cc
extern int some_shared_var;
void TestCtrl::asyncHandleHttpRequest(const HttpRequestPtr &req,
                                      std::function<void (const HttpResponsePtr &)> &&callback)
{
    auto resp=HttpResponse::newHttpResponse();
    auto cb = callback;
    drogon::app().getLoop()-> queueInLoop([resp, cb]() { // As i understand it always return main thread's loop
        resp->setBody(std::to_string(some_shared_var)); // Read here
        cb(resp);
    });
}

But maybe are there any better practices?

[Mis1eader-dev]

You can use atomic variables for simple primitive data types:

#include <atomic>
std::atomic_int some_shared_var;

// in a writer function..
some_shared_var = std::rand();

// in a reader function..
auto value = some_shared_var; // or .load()

Or use mutexes and locks for containers or complex data types:

#include <shared_mutex>
std::shared_mutex some_shared_var_mtx;

// in a writer function..
std::scoped_lock lock(some_shared_var_mtx);
some_shared_var = "complex";

// in a reader function..
std::shared_lock lock(some_shared_var_mtx);
auto value = some_shared_var;

[pyretttt]

As soon as drogon's thread model strongly relies on thread pool and event loop doesn't it imply that we should avoid locking?