properly ending an infinite std::thread

Question

I have a reusable class that starts up an infinite thread. this thread can only be killed by calling a stop function that sets a kill switch variable. When looking around, there is quite a bit of argument over volatile vs atomic variables.

The following is my code: program.cpp

int main()
{
ThreadClass threadClass;
    threadClass.Start();
    Sleep(1000);
    threadClass.Stop();
    Sleep(50);
    threaClass.Stop();
}

ThreadClass.h

#pragma once
#include <atomic>
#include <thread>

class::ThreadClass
{
public:
    ThreadClass(void);
    ~ThreadClass(void);
    void Start();
    void Stop();
private:
void myThread();
    std::atomic<bool> runThread;
    std::thread theThread;
};

ThreadClass.cpp

#include "ThreadClass.h"
    ThreadClass::ThreadClass(void)
    {
        runThread = false;
    }

    ThreadClass::~ThreadClass(void)
    {
    }

    void ThreadClass::Start()
    {
        runThread = true;
        the_thread = std::thread(&mythread, this);
    }

    void ThreadClass::Stop()
    {
        if(runThread)
        {
            runThread = false;
            if (the_thread.joinable())
            {
                the_thread.join();
            }
        }
    }

    void ThreadClass::mythread()
    {
        while(runThread)
        {
            //dostuff
            Sleep(100);  //or chrono
        }
    }

The code that i am representing here mirrors an issue that our legacy code had in place. We call the stop function 2 times, which will try to join the thread 2 times. This results in an invalid handle exception. I have coded the Stop() function in order to work around that issue, but my question is why would the the join fail the second time if the thread has completed and joined? Is there a better way programmatically to assume that the thread is valid before trying to join?