C++ - How to run a class in separate thread and reference functions from same class in main thread

I have this:

class VibraniumEngine {
public:
    VibraniumEngine(VibraniumEngine const &) = delete;
    VibraniumEngine(VibraniumEngine &&) = delete;

    VibraniumEngine& operator= (VibraniumEngine const&) = delete;
    VibraniumEngine& operator= (VibraniumEngine&&) = delete;

    static VibraniumEngine* instance()
    {
        static VibraniumEngine instance;
        return &instance;
    }

    void Start()
    {
        while(true){
            // Do stuff
        }
    }

    void Run();
};

#define sVibraniumEngine VibraniumEngine::instance()

int main()
{
    std::thread vibraniumEngineThread (&VibraniumEngine::Start, sVibraniumEngine);

    //How can I call here method `Run` as if it was called from `vibraniumEngineThread` context ?
}

This creates a new thread of class VibraniumEngine and main thread continues execution.

Function VibraniumEngine::Start holds while loop.

Vibranium engine has other public variables and methods rather than just Start.

Is there a way to call these methods from the main thread as if they were called from vibraniumEngineThread, aka in the context of the created thread, not from the main thread?

> Is there a way to call these methods from the main thread as if they were called from vibraniumEngineThread, aka in the context of the created thread, not from the main thread?

Not directly, no. You would have to setup your own queuing system, where the main thread can push requests into the queue, and then the worker thread pulls out requests from the queue and executes them as needed.

For example:

#include <queue>
#include <mutex>
#include <memory>
class VibraniumEngine {
public:
VibraniumEngine(VibraniumEngine const &) = delete;
VibraniumEngine(VibraniumEngine &&) = delete;
VibraniumEngine& operator= (VibraniumEngine const&) = delete;
VibraniumEngine& operator= (VibraniumEngine&&) = delete;
static VibraniumEngine* instance()
{
static VibraniumEngine instance;
return &instance;
}
class Request
{
public:
virtual void DoAction() = 0;
};
using RequestPtr = std::unique_ptr<Request>;
void Start()
{
while (true){
{
std::unique_lock<std::mutex> lk(m_lock);
if (!m_requests.empty()) {
std::queue<RequestPtr> l_requests;
l_requests.swap(m_requests);
lk.unlock();
while (!l_requests.empty()) {
RequestPtr request = std::move(l_requests.front());
l_requests.pop();
request->DoAction();
}
}
}
// Do Other Stuff...
}
}
void Run() { ... }
template<typename T, typename... Args>
void AddRequest(Args&&... args)
{
std::lock_guard<std::mutex> lk(m_lock);
m_requests.push(std::make_unique<T>(std::forward<Args>(args)...));
}
private:
std::queue<RequestPtr> m_requests;
std::mutex m_lock;
};
#define sVibraniumEngine VibraniumEngine::instance()
class CallVibraniumEngineRun : public VibraniumEngine::Request
{
public:
void DoAction() override {
sVibraniumEngine->Run();
}
};
int main()
{
std::thread vibraniumEngineThread (&VibraniumEngine::Start, sVibraniumEngine);
...
sVibraniumEngine->AddRequest<CallVibraniumEngineRun>();
...
return 0;
}