CODEWITHSUNDEEP
c++multithreadingc++11
user5058091
user5058091

Reputation:

Is there a reliable way to force a thread to stop in C++? (especially detached ones)

I am recently working with threads in C++11. now I am thinking about how to force stop a thread. I couldn't find it on stackoverflow, and also tried these.

and I have no more ideas. I have heard about WinAPI, but I want a portable solution. (that also means I wont use fork())

Can you please give me a solution of this? I really want to do it.

Upvotes: 4

Views: 5325

Answers (2)

David Haim
David Haim

Reputation: 26476

One of the biggest problems with force closing a thread in C++ is the RAII violation.

When a function (and subsequently, a thread), gracefully finishes, everything it held is gracefully cleaned up by the destructors of the objects the functions/threads created.

Memory gets freed,
OS resources (handles, file descriptors etc.) are closed and returned to the OS
Locks are getting unlocked so other threads can use the shared resources they protect.
other important tasks are preformed (such as updating counters, logging, etc.).

If you brutally kill a thread (aka by TerminateThread on Windows, for example), non of these actually happen, and the program is left in a very dangerous state.

A (not-so) common pattern that can be used is to register a "cancellation token" on which you can monitor and gracefully shut the thread if other thread asks so (a la TPL/PPL). something like

auto cancellationToken = std::make_shared<std::atomic_bool>();
cancellationToken->store(false);

class ThreadTerminator : public std::exception{/*...*/};

std::thread thread([cancellationToken]{
  try{
    //... do things
    if (cancellationToken->load()){
       //somone asked the thred to close
       throw ThreadTerminator ();
    }
    //do other things...
    if (cancellationToken->load()){
       //somone asked the thred to close
       throw ThreadTerminator ();
    }
   //...

  }catch(ThreadTerminator){
    return;
  }

});

Usually, one doesn't even open a new thread for a small task, it's better to think of a multi threaded application as a collection of concurrent tasks and parallel algorithms. one opens a new thread for some long ongoing background task which is usually performed in some sort of a loop (such as, accepting incoming connections).

So, anyway, the cases for asking a small task to be cancelled are rare anyway.

tldr:

Is there a reliable way to force a thread to stop in C++?

No.

Upvotes: 7

2785528
2785528

Reputation: 5566

Here is my approach for most of my designs:

Think of 2 kinds of Threads:

1) primary - I call main.

2) subsequent - any thread launched by main or any subsequent thread

When I launch std::thread's in C++ (or posix threads in C++):

a) I provide all subsequent threads access to a boolean "done", initialized to false. This bool can be directly passed from main (or indirectly through other mechanisms).

b) All my threads have a regular 'heartbeat', typically with a posix semaphore or std::mutex, sometimes with just a timer, and sometimes simply during normal thread operation.

Note that a 'heartbeat' is not polling.

Also note that checking a boolean is really cheap.

Thus, whenever main wants to shut down, it merely sets done to true and 'join's with the subsequent threads.

On occasion main will also signal any semaphore (prior to join) that a subsequent thread might be waiting on.

And sometimes, a subsequent thread has to let its own subsequent thread know it is time to end.

Here is an example -

main launching a subsequent thread:

std::thread*  thrd = 
    new std::thread(&MyClass_t::threadStart, this, id);
assert(nullptr != thrd);

Note that I pass the this pointer to this launch ... within this class instance is a boolean m_done.

Main Commanding shutdown:

In main thread, of course, all I do is

m_done = true;

In a subsequent thread (and in this design, all are using the same critical section):

   void threadStart(uint id) {
      std::cout << id << " " << std::flush; // thread announce

      do {

         doOnce(id);  // the critical section is in this method

      }while(!m_done);   // exit when done
   }

And finally, at an outer scope, main invokes the join.

Perhaps the take away is - when designing a threaded system, you should also design the system shut down, not just add it on.

Upvotes: 1

Related Questions