Уперся в тупик с потоками. Прошу подсказки

void CController::Execute()
{
    executeMutex.lock(); // Это попытка как-то исправить ситуацию...
    while (!m_bTerminate)
    {
            m_pView->StartDrawing(); //Сигнал "Визуализатору", что начинается фаза отображения объектов.
//До вызова FinishDrawing  внутри следующих процедур будут вызваться из "Визуализатора" процедуры отрисовки
 
        ManageFlyCycle(); //Здесь запускаются параллельные расчеты в вспомогательных потоках.
                    if (GameMode.eMode == emChase)
        {
            ReLinkInsect();//Определение новых пар для "погони".
            RunWaspCycle();
        }
        else
            TestFlyInfection();
 
        m_pView->FinishDrawing();//Сигнал "Визуализатору", что фаза отображения объектов завершена.
    }
    m_pView->OnControllerTerminate(); //Сигнал "Визуализатору" об уничтожении Контроллера
    executeMutex.unlock(); // Это попытка как-то исправить ситуацию...
}

void CController::Terminate()
{
    m_bTerminate = true;
    std::thread([=]() {executeMutex.lock(); executeMutex.unlock();}).detach();
}

class CController: public IControllerInterface, public IThreadInterface
{
//.................................................
private:
    std::atomic<bool> m_bTerminate;
//.................................................
}

void CController::Terminate()
{
    m_bTerminate = true;
}
 
void CController::Execute()
{
    while (!m_bTerminate)
    {
//Тут внутренние процедуры, они остались, работают в этом же потоке, что и Execute()
//Все вызовы Визуализатора закомментарены.
    }
    m_pView->OnControllerTerminate(); //Сюда мы должны попасть после изменения флага m_bTerminate
}

void WaspFlyGLFrm::StartSimulation()
{
m_pController = new CController(this);//this - это Визулизатор.
m_pControllerThread = new std::thread(CController::Execute, m_pController);
//m_pController и m_pControllerThread - члены класса WaspFlyGLFrm
}

void WaspFlyGLFrm::DestroyController()
{
   if (m_pController && m_pControllerThread)
   {
        m_pController->Terminate(); //Terminate() описан выше, там только присвоение флага.
   }
}

{
if (m_pControllerThread->joinable())
  m_pControllerThread->join();
delete m_pController;
delete m_pControllerThread;
m_pController = NULL;
m_pControllerThread = NULL;
}

m_pControllerThread = new std::thread(&CController::Execute, m_pController);

static std::atomic<bool> m_bTerminate

class ...........
{
....
    std::thread m_ControllerThread;
....
};
 
 
....
m_ControllerThread = std::thread(....
....

void CController::Execute()
{
    while (!m_bTerminate)
    {
    }
    m_pView->OnControllerTerminate();
}
// ...
void WaspFlyGLFrm::OnControllerTerminate()
{
if (m_pControllerThread->joinable())
   m_pControllerThread->join(); // Тут будет висеть 
// ...
}

#include <iostream>
#include <atomic>
#include <thread>
#include <chrono>
#include <memory>
 
class CController
{
private:
    std::atomic<bool> m_bTerminate{};
    std::thread m_ControllerThread; 
public:
    void Terminate()
    {
        if(m_ControllerThread.joinable())
        {
            m_bTerminate = true;
            m_ControllerThread.join();
        }
        m_bTerminate = false;
    }
     
    void Execute()
    {
        Terminate();
        m_ControllerThread=std::thread([&m_bTerminate=m_bTerminate]
        {
            using namespace std::chrono_literals;
            while(!m_bTerminate)
            {
                std::this_thread::sleep_for(100ms);
            }
        });
    }
    
    ~CController()
    {
        Terminate();
    }
};
 
class WaspFlyGLFrm
{
    std::unique_ptr<CController> m_Controller;
public:
    void StartSimulation()
    {
        m_Controller = std::make_unique<CController>();
        m_Controller->Execute();
    }
    
    void DestroyController()
    {
        m_Controller.reset();
    }
};
 
 
int main()
{
    using namespace std::chrono_literals;
    
    WaspFlyGLFrm w;
    w.StartSimulation();
 
    std::this_thread::sleep_for(3s);
    
    w.DestroyController();
}

m_ControllerThread=std::thread([&m_bTerminate=m_bTerminate]
{
...
}

m_ControllerThread=std::thread([&Terminate=m_bTerminate]