How to check if a std thread is still running

Question

How can I check if a std  thread is still running  in a platform independent way   It lacks a timed join   method and joinable   is not meant for that   I thought of locking a mutex with a std  lock guard in the thread and using the try lock   method of the mutex to determine if it is still locked  the thread is running   but it seems unnecessarily complex to me   Do you know a more elegant method   Update  To be clear  I want to check if the thread cleanly exited or not  A  hanging  thread is considered running for this purpose

User · Answer

An easy solution is to have a boolean variable that the thread sets to true on regular intervals, and that is checked and set to false by the thread wanting to know the status. If the variable is false for to long then the thread is no longer considered active.

A more thread-safe way is to have a counter that is increased by the child thread, and the main thread compares the counter to a stored value and if the same after too long time then the child thread is considered not active.

Note however, there is no way in C++11 to actually kill or remove a thread that has hanged.

Edit How to check if a thread has cleanly exited or not: Basically the same technique as described in the first paragraph; Have a boolean variable initialized to false. The last thing the child thread does is set it to true. The main thread can then check that variable, and if true do a join on the child thread without much (if any) blocking.

Edit2 If the thread exits due to an exception, then have two thread "main" functions: The first one have a try-catch inside which it calls the second "real" main thread function. This first main function sets the "have_exited" variable. Something like this:

bool thread_done = false;

void *thread_function(void *arg)
{
    void *res = nullptr;

    try
    {
        res = real_thread_function(arg);
    }
    catch (...)
    {
    }

    thread_done = true;

    return res;
}

User · Answer

This simple mechanism you can use for detecting finishing of a thread without blocking in join method   std  thread thread   amp thread          sleep 3       thread detach         while thread joinable        sleep 1

User · Answer

You can always check if the thread s id is different than std  thread  id   default constructed  A Running thread has always a genuine associated id  Try to avoid too much fancy stuff

User · Answer

If you are willing to make use of C  11 std  async and std  future for running your tasks  then you can utilize the wait for function of std  future to check if the thread is still running in a neat way like this    include  lt future gt   include  lt thread gt   include  lt chrono gt   include  lt iostream gt   int main         using namespace std  chrono literals          Run some task on new thread  The launch policy std  launch  async        makes sure that the task is run asynchronously on a new thread         auto future   std  async std  launch  async               std  this thread  sleep for 3s           return 8                  Use wait for   with zero milliseconds to check thread status      auto status   future wait for 0ms           Print status      if  status    std  future status  ready            std  cout  lt  lt   Thread finished   lt  lt  std  endl        else           std  cout  lt  lt   Thread still running   lt  lt  std  endl             auto result   future get       Get result      If you must use std  thread then you can use std  promise to get a future object    include  lt future gt   include  lt thread gt   include  lt chrono gt   include  lt iostream gt   int main         using namespace std  chrono literals          Create a promise and get its future      std  promise lt bool gt  p      auto future   p get future            Run some task on a new thread      std  thread t   amp p            std  this thread  sleep for 3s           p set value true      Is done atomically                  Get thread status using wait for as before      auto status   future wait for 0ms           Print status      if  status    std  future status  ready            std  cout  lt  lt   Thread finished   lt  lt  std  endl        else           std  cout  lt  lt   Thread still running   lt  lt  std  endl             t join       Join thread      Both of these examples will output   Thread still running   This is of course because the thread status is checked before the task is finished   But then again  it might be simpler to just do it like others have already mentioned    include  lt thread gt   include  lt atomic gt   include  lt chrono gt   include  lt iostream gt   int main         using namespace std  chrono literals       std  atomic lt bool gt  done false      Use an atomic flag          Run some task on a new thread         Make sure to set the done flag to true when finished         std  thread t   amp done            std  this thread  sleep for 3s           done   true                  Print status      if  done            std  cout  lt  lt   Thread finished   lt  lt  std  endl        else           std  cout  lt  lt   Thread still running   lt  lt  std  endl             t join       Join thread      Edit   There s also the std  packaged task for use with std  thread for a cleaner solution than using std  promise    include  lt future gt   include  lt thread gt   include  lt chrono gt   include  lt iostream gt   int main         using namespace std  chrono literals          Create a packaged task using some task and get its future      std  packaged task lt void   gt  task              std  this thread  sleep for 3s               auto future   task get future            Run task on new thread      std  thread t std  move task            Get thread status using wait for as before      auto status   future wait for 0ms           Print status      if  status    std  future status  ready                              t join       Join thread

User · Answer

Create a mutex that the running thread and the calling thread both have access to  When the running thread starts it locks the mutex  and when it ends it unlocks the mutex  To check if the thread is still running  the calling thread calls mutex try lock    The return value of that is the status of the thread   Just make sure to unlock the mutex if the try lock worked   One small problem with this  mutex try lock   will return false between the time the thread is created  and when it locks the mutex  but this can be avoided using a slightly more complex method

User · Answer

Surely have a mutex-wrapped variable initialised to false  that the thread sets to true as the last thing it does before exiting  Is that atomic enough for your needs

[c++] How to check if a std::thread is still running?

Examples related to c++

Examples related to multithreading

Examples related to c++11

Examples related to stdthread