Re: Boost.Threads - thread_desc concept

From: Alexander Terekhov (terekhov_at_[hidden])
Date: 2001-06-29 09:58:20

> The difference is that a detached thread does not
> need to run to completion (in fact they are
> usually coded with infinite loops) while a joined
> thread does.

Bill, for never ending thread it is absolutely
irrelevant whether a thread was detached or not!
The difference is that a detached thread does
not need to be _joined_ in order to reclaim
resources (e.g. thread id) -- it will be done
automatically upon thread termination. In other
words for not detached threads thread ids stays
valid until join() is called -- even if a thread
had already terminated (thread function ended
via return or pthread_exit) its id/thread
function return value/etc.. will be preserved
and will stay preserved until join(). For never
ending threads reclamation of resources never
occurs hence there is no difference at all with
respect to detached status.

> (BTW, the pthreads standard correctly points out that join() is a
> convenience... detached threads can be "waited on" through a
> condition variable.

the new standard appears to strengthen the termination
guaranties with respect to join. the new version says:

33690 ... For instance, after pthread_join ( ) returns, any
33691 application-provided stack storage could be reclaimed.

CV solution does not allow that!!

as for thread object design questions and join/detach please
consider the following POSIX example attached below -- it
creates a new thread type (with a capability for timed join).
Hopefully it will help to clarify matters.

regards,
alexander.

----
6086 /*
6087  * Construct a thread variety entirely from existing functions
6088  *  with which a join can be done, allowing the join to time out.
6089  */
6090 #include <pthread.h>
6091 #include <time.h>
6092 struct timed_thread {
6093   pthread_t t;
6094   pthread_mutex_t m;
6095   int exiting;
6096   pthread_cond_t exit_c;
6097   void *(*start_routine)(void *arg);
6098   void *arg;
6099   void *status;
6100 };
6101 typedef struct timed_thread *timed_thread_t;
6102 static pthread_key_t timed_thread_key;
6103 static pthread_once_t timed_thread_once = PTHREAD_ONCE_INIT;
6104 static void timed_thread_init()
6105 {
6106   pthread_key_create(&timed_thread_key, NULL);
6107 }
6108 static void *timed_thread_start_routine(void *args)
6109 /*
6110  * Routine to establish thread-specific data value and run the actual
6111  * thread start routine which was supplied to timed_thread_create().
6112  */
6113 {
6114   timed_thread_t tt = (timed_thread_t) args;
6115   pthread_once(&timed_thread_once, timed_thread_init);
6116   pthread_setspecific(timed_thread_key, (void *)tt);
6117   timed_thread_exit((tt->start_routine)(tt->arg));
6118 }
6119 int timed_thread_create(timed_thread_t ttp, const pthread_attr_t
*attr,
6120   void *(*start_routine)(void *), void *arg)
6121 /*
6122  * Allocate a thread which can be used with timed_thread_join().
6123  */
6124 {
6125   timed_thread_t tt;
6126   int result;
6127   tt = (timed_thread_t) malloc(sizeof(struct timed_thread));
6128   pthread_mutex_init(&tt->m,NULL);
6129   tt->exiting = FALSE;
6130   pthread_cond_init(&tt->exit_c,NULL);
6131   tt->start_routine = start_routine;
6132   tt->arg = arg;
6133   tt->status = NULL;
6134   if ((result = pthread_create(&tt->t, attr,
6135         timed_thread_start_routine, (void *)tt)) != 0) {
6136     free(tt);
6137     return result;
6138   }
6139   pthread_detach(tt->t);
6140   ttp = tt;
6141   return 0;
6142 }
6143 int timed_thread_join(timed_thread_t tt,
6144                       struct timespec *timeout,
6145                       void **status)
6146 {
6147   int result;
6148   pthread_mutex_lock(&tt->m);
6149   result = 0;
6150   /*
6151    * Wait until the thread announces that it is exiting,
6152    * or until timeout.
6153    */
6154   while (result == 0 && ! tt->exiting) {
6155     result = pthread_cond_timedwait(&tt->exit_c, &tt->m, timeout);
6156   }
6157   pthread_mutex_unlock(&tt->m);
6158   if (result == 0 && tt->exiting) {
6159     *status = tt->status;
6160     free((void *)tt);
6161     return result;
6162   }
6163   return result;
6164 }
6165 void timed_thread_exit(void *status)
6166 {
6167   timed_thread_t tt;
6168   void *specific;
6169   if ((specific=pthread_getspecific(timed_thread_key)) == NULL){
6170     /*
6171      * Handle cases which won't happen with correct usage.
6172      */
6173     pthread_exit( NULL);
6174   }
6175   tt = (timed_thread_t) specific;
6176   pthread_mutex_lock(&tt->m);
6177   /*
6178    * Tell a joiner that we're exiting.
6179    */
6180   tt->status = status;
6181   tt->exiting = TRUE;
6182   pthread_cond_signal(&tt->exit_c);
6183   pthread_mutex_unlock(&tt->m);
6184  /*
6185   * Call pthread exit() to call destructors and really
6186   * exit the thread.
6187   */
6188   pthread_exit(NULL);
6189 }