What are the problems you may encounter when destroying a join thread pointer? (i.e. call delete thread). The acceleration link is a bit fuzzy, more accurate answers are required.
Here is an example:
Suppose a child thread is stuck on an invincible system call, such as read(0), and no one is picking a keyboard. Thus, the call thread->interrupt()that follows thread->try_join_for()leaves the thread compatible. What to do?
From the reference manual, it seems that you need to either disconnect the stream or leak the stream pointer. What actually happens when a stuck thread disconnects or a pointer leaks out is beyond the scope of this question.
Background:
The reference boost::thread::~thread()contains the following wording. Being the "she sells seashells on the seashore" of the BOOST reference guide, it requires reading three or four times before it can be analyzed;
Either implicitly disabling or merging a joinable () stream in its destructor can lead to debugging errors (to detach) or performance (to merge) errors that occur only when an exception occurs. Thus, the programmer must ensure that the destructor will never execute while the thread is still compatible.
Shorter than this (from what I can say) there is (that) this (bad) idea (to) destroy (a) boost: :( thread) pointer (while) it (is) still (is) joinable). And who raised the exception? Baby stream? Destructor?