Re: Boost.Threads - thread_desc concept

From: williamkempf_at_[hidden]
Date: 2001-06-30 08:33:19

--- In boost_at_y..., "Alexander Terekhov" <terekhov_at_d...> wrote:
> 
> > 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.

Not 100% true.  It's undefined behavior to allow a program to 
terminate with a thread that's never been joined or detached.  
Theoretically such usage could lead to system leaks that can't be 
reclaimed (though in practice I'd be surprised to find an 
implementation that behaves that way).

> > (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!!

Yes, it does.  With a CV solution the thread is created detached and 
later the CV is waited on.  That or the thread is immediately 
detached after waiting on the CV.  Both result in the same behavior 
as join().  A join() concept is a convenience, and nothing more.
 
> 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;

Ahh... notice you're design uses a CV to implement the join.  You've 
just proven that join() is a convenience ;).
 
> 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 }

Other than proving my point, I don't see what else this example is 
supposed to prove.

Bill Kempf