How do I terminate a thread in C++11?

by

  1. You could call std::terminate() from any thread and the thread you’re referring to will forcefully end.

  2. 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.

  3. 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.

More Related Contents:

  1. C++11 introduced a standardized memory model. What does it mean? And how is it going to affect C++ programming?
  2. What happens to a detached thread when main() exits?
  3. Thread pooling in C++11
  4. What are the correct link options to use std::thread in GCC under linux?
  5. Why is the destructor of a future returned from `std::async` blocking?
  6. What does the thread_local mean in C++11?
  7. How to check if a std::thread is still running?
  8. Does MinGW-w64 support std::thread out of the box when using the Win32 threading model?
  9. C++11 thread-safe queue
  10. What exactly is std::atomic?
  11. How to implement multithread safe singleton in C++11 without using
  12. Difference between pointer and reference as thread parameter
  13. std::unique_lock or std::lock_guard?
  14. Does the C++ volatile keyword introduce a memory fence?
  15. Which std::async implementations use thread pools?
  16. How can I use something like std::vector?
  17. Get the status of a std::future
  18. Delayed start of a thread in C++ 11
  19. What is std::promise?
  20. Is it smart to replace boost::thread and boost::mutex with c++11 equivalents?
  21. C++11 STL containers and thread safety
  22. Can I use std::async without waiting for the future limitation?
  23. Passing arguments to std::async by reference fails
  24. C++ terminate called without an active exception
  25. C++11 std::threads vs posix threads
  26. Understanding std::atomic::compare_exchange_weak() in C++11
  27. Double-Checked Lock Singleton in C++11
  28. std::thread calling method of class [duplicate]
  29. Write concurrently vector
  30. About thread-safety of weak_ptr

Leave a Comment