C++11. thread, mutex, thread-safety

void Trainer::start()
{
    const HANDLE hMutex = CreateMutex(NULL, FALSE, NULL);
 
    // Begin thread for KEY HANDLING
    std::thread keyHandler(&Trainer::keyHandling, this, hMutex);
    keyHandler.detach();
 
    // Begin thread for TRAINER ACTIONS
    std::thread action(&Trainer::actions, this, hMutex);
    action.join();
 
    CloseHandle(hMutex);
}

    while(active)
    {
        WaitForSingleObject(hMutex, INFINITE);//поток тормознул здесь

    while(true)
    {
        WaitForSingleObject(hMutex, INFINITE);
 
        // Close Trainer IF GAME is NOT RUNNING
        if(!gameIsRun())
        {
            active = false;
            ReleaseMutex(hMutex);//Освободили мьютекс
            break;//Вышли из цикла
        }
//...
//поток завершился

    std::thread action(&Trainer::actions, this, hMutex);
    action.join();//пошли дальше
 
    CloseHandle(hMutex);//Прибили мьютекс

    while(active)
    {//А теперь управление передалось сюда,
        WaitForSingleObject(hMutex, INFINITE);//а мьютекс уже прибит
//С MSDN: If this handle is closed while the wait is still pending, the function's behavior is undefined.

#include <mutex>
class Trainer {
    std::mutex hMutex;
//...
}
void Trainer::start()
{
    // Begin thread for KEY HANDLING
    std::thread keyHandler(&Trainer::keyHandling, this);
    keyHandler.detach();
 
    // Begin thread for TRAINER ACTIONS
    std::thread action(&Trainer::actions, this);
    action.join();
}

    std::thread keyHandler(&Trainer::keyHandling, this, hMutex);//Здесь, то мьютекс останется не закрытым
//...
    std::thread action(&Trainer::actions, this, hMutex);//Если здесь, то еще и keyHandling стартанет, 
//но не завершится, конечно, если его остановка еще где-то не предусмотрена

WaitForSingleObject(hMutex, INFINITE);
//
ReleaseMutex(hMutex);

 hMutex.lock();
//
hMutex.unlock();

std::lock_guard<std::mutex> lock(hMutex);

hMutex.lock();

#include <iostream>
#include <thread>
#include <queue>
#include <atomic>
#include <array>
#include <chrono>
#include <windows.h>
 
 
class EmptyQueue : public std::exception
{
    const char *what() const noexcept override
    {
        return "Queue is empty";
    }
};
 
 
template<typename T>
class SSQueue
{
public:
    void push(const T &obj)
    {
        std::lock_guard<std::mutex> locker(mMutex);
        mQueue.emplace(obj);
    }
    void pop(T &destObj)
    {
        std::lock_guard<std::mutex> locker(mMutex);
        if(mQueue.empty())
        {
            throw EmptyQueue();
        }
        destObj = std::move(mQueue.front());//???
        mQueue.pop();
    }
private:
    std::mutex mMutex;
    std::queue<T> mQueue;
};
 
 
 
 
constexpr int KEY_W = 0x57;
constexpr int KEY_A = 0x41;
constexpr int KEY_S = 0x53;
constexpr int KEY_D = 0x44;
 
 
int main()
{
    std::atomic<bool> runningKeyHandling(true);
    SSQueue<int> messageQueue;
    std::thread keyHangler
    (
        [&messageQueue, &runningKeyHandling]()
        {
            std::array<int, 5> keys{{VK_ESCAPE, KEY_W, KEY_A, KEY_S, KEY_D}};
            while(runningKeyHandling)
            {
                for(auto key: keys)
                {
                    if(GetAsyncKeyState(key))
                    {
                        messageQueue.push(key);
                    }
                }
                //std::this_thread::yield();
                std::this_thread::sleep_for(std::chrono::milliseconds(20));
            }
        }
    );
    bool running = true;
    while(running)
    {
        try
        {
            while(true)
            {
                int key;
                messageQueue.pop(key);
                if(key == VK_ESCAPE)
                {
                    running = false;
                    break;
                }
                switch(key)
                {
                case KEY_W:
                    std::cout << "key W" << std::endl;
                    break;
                case KEY_A:
                    std::cout << "key A" << std::endl;
                    break;
                case KEY_S:
                    std::cout << "key S" << std::endl;
                    break;
                case KEY_D:
                    std::cout << "key D" << std::endl;
                    break;
                }
            }
        } catch (const EmptyQueue&)
        {
        }
        std::this_thread::yield();
    }
    runningKeyHandling.store(false);
    if(keyHangler.joinable())
    {
        keyHangler.join();
    }
}

        // Rewrite data if FREEZE FLAG enabled
        if(bGodMode)
        {
            game.updatePoints();
        }
        if(bNoReload)
        {
            game.updateAmmo();
        }

    bool running = true;
    while(running)
    {
        std::this_thread::yield();
        try{
            int key;
            messageQueue.pop(key);
            if(key == VK_ESCAPE)
            {
                running = false;
                break;
            }
            switch(key)
            {
            case KEY_W:
                std::cout << "key W" << std::endl;
                break;
            case KEY_A:
                std::cout << "key A" << std::endl;
                break;
            case KEY_S:
                std::cout << "key S" << std::endl;
                break;
            case KEY_D:
                std::cout << "key D" << std::endl;
                break;
            }
        }
        catch(const EmptyQueue&)
        {
        }
    }