How do I terminate a thread in C 11

Question

I don t need to terminate the thread correctly  or make it respond to a  terminate  command  I am interested in terminating the thread forcefully using pure C  11

User · Answer

Tips of using OS-dependent function to terminate C++ thread:

std::thread::native_handle() only can get the thread’s valid native handle type before calling join() or detach(). After that, native_handle() returns 0 - pthread_cancel() will coredump.
To effectively call native thread termination function(e.g. pthread_cancel()), you need to save the native handle before calling std::thread::join() or std::thread::detach(). So that your native terminator always has a valid native handle to use.

More explanations please refer to: http://bo-yang.github.io/2017/11/19/cpp-kill-detached-thread .

User · Answer

Howard Hinnant s answer is both correct and comprehensive  But it might be misunderstood if it s read too quickly  because std  terminate    whole process  happens to have the same name as the  quot terminating quot  that  Alexander V had in mind  1 thread   Summary   quot terminate 1 thread   forcefully  target thread doesn t cooperate    pure C  11   No way  quot

User · Answer

I guess the thread that needs to be killed is either in any kind of waiting mode  or doing some heavy job  I would suggest using a  naive  way   Define some global boolean   std  atomic bool stop thread 1   false    Put the following code  or similar  in several key points  in a way that it will cause all functions in the call stack to return until the thread naturally ends   if  stop thread 1      return    Then to stop the thread from another  main  thread   stop thread 1   true  thread1 join     stop thread 1   false     for next time  this can be when starting the thread instead

User · Answer

This question actually have more deep nature and good understanding of the multithreading concepts in general will provide you insight about this topic  In fact there is no any language or any operating system which provide you facilities for asynchronous abruptly thread termination without warning to not use them  And all these execution environments strongly advise developer or even require build multithreading applications on the base of cooperative or synchronous thread termination  The reason for this common decisions and advices is that all they are built on the base of the same general multithreading model   Let s compare multiprocessing and multithreading concepts to better understand advantages and limitations of the second one   Multiprocessing assumes splitting of the entire execution environment into set of completely isolated processes controlled by the operating system  Process incorporates and isolates execution environment state including local memory of the process and data inside it and all system resources like files  sockets  synchronization objects  Isolation is a critically important characteristic of the process  because it limits the faults propagation by the process borders  In other words  no one process can affects the consistency of any another process in the system  The same is true for the process behaviour but in the less restricted and more blur way  In such environment any process can be killed in any  arbitrary  moment  because firstly each process is isolated  secondly  operating system have full knowledges about all resources used by process and can release all of them without leaking  and finally process will be killed by OS not really in arbitrary moment  but in the number of well defined points where the state of the process is well known   In contrast  multithreading assumes running multiple threads in the same process  But all this threads are share the same isolation box and there is no any operating system control of the internal state of the process  As a result any thread is able to change global process state as well as corrupt it  At the same moment the points in which the state of the thread is well known to be safe to kill a thread completely depends on the application logic and are not known neither for operating system nor for programming language runtime  As a result thread termination at the arbitrary moment means killing it at arbitrary point of its execution path and can easily lead to the process-wide data corruption  memory and handles leakage  threads leakage and spinlocks and other intra-process synchronization primitives leaved in the closed state preventing other threads in doing progress   Due to this the common approach is to force developers to implement synchronous or cooperative thread termination  where the one thread can request other thread termination and other thread in well-defined point can check this request and start the shutdown procedure from the well-defined state with releasing of all global system-wide resources and local process-wide resources in the safe and consistent way

User · Answer

You could call std  terminate   from any thread and the thread you re referring to will forcefully end  You could arrange for  thread   to be executed on the object of the target thread  without a intervening join   nor detach   on that object   This will have the same effect as option 1  You could design an exception which has a destructor which throws an exception   And then arrange for the target thread to throw this exception when it is to be forcefully terminated   The tricky part on this one is getting the target thread to throw this exception    Options 1 and 2 don t leak intra-process resources  but they terminate every thread   Option 3 will probably leak resources  but is partially cooperative in that the target thread has to agree to throw the exception   There is no portable way in C  11  that I m aware of  to non-cooperatively kill a single thread in a multi-thread program  i e  without killing all threads    There was no motivation to design such a feature   A std  thread may have this member function   native handle type native handle      You might be able to use this to call an OS-dependent function to do what you want   For example on Apple s OS s  this function exists and native handle type is a pthread t   If you are successful  you are likely to leak resources

[c++] How do I terminate a thread in C++11?

Examples related to c++

Examples related to multithreading

Examples related to c++11