Reputation: 401
For a detached thread we can't use joinable()
and using bool variables seems to be not the correct way. Is there a way to check if the detached thread is still alive and running?
Upvotes: 3
Views: 4548
Reputation: 12485
There are a few ways to tackle this. If you're set on threads, then you can use a std::future<void>
to detect when it has exited:
std::promise<void> promised_thread_exit;
std::future<void> thread_exited = promised_thread_exit.get_future();
std::thread(
[] (std::promise<void> promised_thread_exit)
{
promised_thread_exit.set_value_at_thread_exit();
DoBackgroundWork();
},
std::move(promised_thread_exit));
thread.detach();
// later...
thread_exited.get();
However, this seems like lot of work. A std::thread
is quite a low level primitive. If the goal is just to perform some work in the background, then std::async
is a better option:
std::future<void> work_complete = std::async(std::launch::async, DoBackgroundWork());
// later...
work_complete.get();
In either case, if you need to check on the work's state without blocking, you can do so by waiting on the future
with a timeout of 0:
using namespace std::chrono_literals;
//...
if (work_complete.wait_for(0s) == std::future_status::ready)
{
// work has finished
}
That being said, checking the state like this is rarely necessary. If it seems to be, then you should consider if there's a simpler alternative.
Upvotes: 5
Reputation: 652
You can use a std::condition_variable
to notify your main thread when the detached one is finished:
#include <iostream>
#include <mutex>
#include <thread>
int main()
{
std::mutex mutex;
std::condition_variable cv;
std::thread t([&]() {
std::cout << "Wait" << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(1));
std::unique_lock<std::mutex> lock(mutex);
std::cout << "Thread end" << std::endl;
cv.notify_all();
});
t.detach();
std::unique_lock<std::mutex> lock(mutex);
cv.wait(lock);
std::cout << "Main end" << std::endl;
return 0;
}
Upvotes: 0