c++ allow background thread to finish before exiting application - c++

Question

c++ win 32 application . VS 2013
I am making use of a 3rd party library.
I want to call 3rd party library's function in a background thread.
I then also want to eventually turn it off.
I suspect I dont give third party enough time to properly shut itself down before I exist the application.
How do I ensure the detached task I started on a separate thread is done before I exit the main().
//this class interfaces with the third part and runs on a separate thread
class ThirdParty
{
void Start(std::string filename)
{
MyApplication application;
FIX::SessionSettings settings(filename);
FIX::FileStoreFactory storeFactory(settings);
FIX::ScreenLogFactory logFactory(settings);
FIX::SocketAcceptor acceptor(application, storeFactory, settings, logFactory);
acceptor.start(); //this third party internally starts new threads and does stuff thats transparent to consumer like myself.
while (m_runEngine)
{}
//this shutsdown a few things and cant execute instantaneously
//This does not finish execution and main() already ends.
acceptor.stop();
}
void Stop()
{
m_runEngine = false;
}
private:
bool m_runEngine{ true };
}
Here is my main() in a win32 application
int _tmain(int argc, _TCHAR* argv[])
{
std::wstring arg = argv[1];
std::string filename = std::string(arg.begin(), arg.end());
ThirdParty myprocess;
std::thread t(&ThirdParty::Start, &myprocess, filename);
t.detach();
while (true)
{
std::string value;
std::cin >> value;
if (value == "quit")
break;
}
myprocess.Stop(); //This line will execute really fast and application will exit without allowing acceptor.stop() to properly finish execution
//How can I ensure acceptor.stop() has finished execution before I move on to the next line and finish the application
return 0;
}

Answer 1

Do not make you thread detached, so that you can wait for it to end using thread::join():
//t.detach() do not detach thread
...
myprocess.Stop();
t.join(); // wait for t to end

Answer 2

I think the following example illustrates the interesting aspects of thread join.
void pause_thread(int n, std::string lbl)
{
std::this_thread::sleep_for (std::chrono::seconds(n));
std::cout << lbl << " pause of " << n << " seconds ended" << std::endl;
}
int t403(void) // in context of thread main
{
std::cout << "Spawning 3 threads...\n" << std::flush;
std::thread t1 (pause_thread, 3, "t1");
std::thread t2 (pause_thread, 2, "t2");
std::thread t3 (pause_thread, 1, "t3");
std::cout << "Done spawning threads, "
"Note that the threads finish out-of-order. \n"
"Now 'main' thread waits for spawned threads to join:\n" << std::flush;
t1.join(); std::cout << "join t1 " << std::flush;
t2.join(); std::cout << "join t2 " << std::flush;
t3.join(); std::cout << "join t3 " << std::flush;
std::cout << "completed join \n"
"note: \n - join sequence is in-order, but finish sequence is out-of-order\n"
" - inference: the threads waited in join main. "<< std::endl;
return(0);
}
Note that the threads are spawned in order: t1, t2, t3.
Note that the threads end in a different order.
But the join is still in the launch order, because that is what main waits for.
Using 'std::flush()' presents the timeline that has been chosen slow enough for human vision.