Threads, Joinable vs Detached

My searches return references that describe how to implement joinable and detached thread, but not why. Please explain or tell me where to find an explanation that contains the concepts:

If you want to <do this> then leave the thread joinable.
If you want to <do that> then detach the thread.

It is all about the future of the thread, and whether and how you need to interact with it.

If you need to get an exit status when the thread completes, or if you need to block one thread until another completes, or wish to share priority, they must be joinable.

If you don't need to hear from the thread again and trust it to complete its mission and clean up after itself, then detach it.

When a thread is started it can be given the address of, for example, a structure. (That is the limit of my knowledge and experience so far.) It can write to that structure providing communications. I am using that to pass values back to the originator. One item of the structure tells the thread to quit and another holds a status that the thread updates. Plus some variables that the thread updates.

Does that change the concepts any?

Edit: If we need to start a thread that monitors or controls something, and it can use, maybe SOAP to communicate, and does not need the parent to do anything, then it can or should be detached.
Is that correct? Does it need clarifications?

or use this

https://www.openmp.org/

Originally Posted by bkelly When a thread is started it can be given the address of, for example, a structure. (That is the limit of my knowledge and experience so far.) It can write to that structure providing communications. I am using that to pass values back to the originator. One item of the structure tells the thread to quit and another holds a status that the thread updates. Plus some variables that the thread updates. Does that change the concepts any? Edit: If we need to start a thread that monitors or controls something, and it can use, maybe SOAP to communicate, and does not need the parent to do anything, then it can or should be detached. Is that correct? Does it need clarifications?

It doesn't change the concepts, but it is really kind of orthogonal to the question of whether a given thread's state should be joinable or detached.

As with all things in programming you should first model what you want to do, then make choices of language features and methods which best fit the model, usually also adjusting the model to make best use of those choices. Then decisions such as whether to detach or make a thread joinable fall out of the model instead of being arbitrary and isolated.

As bigearsbilly has suggested, you might want to build on an existing model, or specification, such as openmp which will define an overall framework for managing threads to best advantage.

Good luck!

Originally Posted by bigearsbilly or use this https://www.openmp.org/

I was unable to discover anything relevant from either of the two links. Did I miss something?

In general I have not recognized the answer. I'll reword:

Detach a thread if you need to <do this>. Otherwise do not detach it.

Originally Posted by bkelly I was unable to discover anything relevant from either of the two links. Did I miss something? In general I have not recognized the answer. I'll reword: Detach a thread if you need to <do this>. Otherwise do not detach it.

OK, let's try saying it another way...

This will appear to be a tautology, but please consider it seriously...

Detach a thread if you [ do not ] need to < join it >. Otherwise do not detach it.

Which implicitly includes the question...

When or why might I need to join a thread?

And again, the short answer to that is: When you need to get the exit status of a thread, or when you need to block one thread until another completes, or if you want to inherit or share scheduling priority among threads, then you will need to join them.

Which seems to not be the answer you are looking for, I suspect because you are really asking, "When I write some arbitrary threaded application, how can I decide when to make use of the joinable or deteched state of threads?".

And the answer to that takes us back to the model of your application - how your model makes use of threads during execution. In other words, the answer depends on where the thread fits into the application's execution model.

Where OpenMP* fits into this picture is explained in their About Us page...

... the OpenMP API is a portable, scalable model that gives shared-memory parallel programmers a simple and flexible interface for developing parallel applications...

Similarly, if you were to ask, "When should I use an integer type vs a float type for a variable in my program?", the answer is of course, "It depends on what you intend your program to do with it after you create it!".

I also found this StackOverflow page which includes another brief discussion and may be helpful.

Hope this helps!

*Note: I am not really familiar with OpenMP and not particularly recommending it, but it is one model for programming threaded applications already mentioned and as such is an example at hand - there are many more. The point being made is the ultimate dependence of the answer upon the chosen model.