Difference between revisions of "User:Kr/A Thread's Life/Example Code"

From Apache OpenOffice Wiki
Jump to: navigation, search
m (Fixed a race - should always do proper error handling to actually see the problems ;-))
m (Fixed more races => A daemon must never detach itself.)
Line 1: Line 1:
 
<code>[cpp]
 
<code>[cpp]
 
//
 
//
−
// gcc -g example.c -o main.bin -lpthread
+
// gcc -Wall -g example.c -o main.bin -lpthread
 
//  
 
//  
  
Line 8: Line 8:
 
#include <pthread.h>
 
#include <pthread.h>
 
#include <string.h>
 
#include <string.h>
 +
#include <unistd.h>
  
  
 
void my_pthread_cancel(pthread_t thread) {
 
void my_pthread_cancel(pthread_t thread) {
 
     int res;
 
     int res;
−
     if (res = pthread_cancel(thread)) {
+
     if ((res = pthread_cancel(thread))) {
−
         fprintf(stderr, "%s - %s\n", __PRETTY_FUNCTION__, strerror(res));
+
         fprintf(stderr, "%s(%p) => %s\n", __PRETTY_FUNCTION__, (void*)thread, strerror(res));
−
         abort();
+
         // There seems to be an issue on Linux with pthread_cancel,
 +
        // returning an error in case "thread" has already terminated,
 +
        // though not joined.
 +
//        abort();
 
     }
 
     }
 
}
 
}
Line 20: Line 24:
 
void my_pthread_join(pthread_t th, void **thread_return) {
 
void my_pthread_join(pthread_t th, void **thread_return) {
 
     int res;
 
     int res;
−
     if (res = pthread_join(th, thread_return)) {
+
     if ((res = pthread_join(th, thread_return))) {
 
         fprintf(stderr, "%s - %s\n", __PRETTY_FUNCTION__, strerror(res));
 
         fprintf(stderr, "%s - %s\n", __PRETTY_FUNCTION__, strerror(res));
 
         abort();
 
         abort();
Line 35: Line 39:
 
     void (*func_)(void);
 
     void (*func_)(void);
 
     pthread_t hd_;
 
     pthread_t hd_;
−
     int      inJoin_;
+
     int      finished_;
 
};
 
};
  
Line 42: Line 46:
 
static unsigned    int daemons_      = 0;  
 
static unsigned    int daemons_      = 0;  
  
−
/* Unregister the given "Daemon" struct
+
 
−
  and terminate this thread.            */
+
static void daemons_join_(int finished) {
−
static void daemon_terminate(Daemon * daemon) {
 
 
     pthread_mutex_lock(&daemons_mutex_);
 
     pthread_mutex_lock(&daemons_mutex_);
−
     -- daemons_;
+
     Daemon * daemon = firstDaemon_;
 +
    while (daemon) {
 +
        Daemon * next = daemon->next_;
 +
 
 +
        if (!finished || daemon->finished_) {
 +
            -- daemons_;
 +
           
 +
            if (daemon->next_)
 +
                daemon->next_->previous_ = daemon->previous_;
 +
           
 +
            if (daemon->previous_)
 +
                daemon->previous_->next_ = daemon->next_;
 +
           
 +
            if (firstDaemon_ == daemon)
 +
                firstDaemon_ = daemon->next_;
 +
 
 +
            pthread_mutex_unlock(&daemons_mutex_);
 +
            my_pthread_join(daemon->hd_, NULL);
 +
            pthread_mutex_lock(&daemons_mutex_);
  
−
    if (daemon->next_)
+
            daemon->hd_ = 0xffffffff;
−
        daemon->next_->previous_ = daemon->previous_;
 
  
−
    if (daemon->previous_)
+
            free(daemon);
−
        daemon->previous_->next_ = daemon->next_;
 
  
−
    if (firstDaemon_ == daemon)
+
            daemon = firstDaemon_;
−
         firstDaemon_ = daemon->next_;
+
        }
 +
         else
 +
            daemon = next;
 +
    }
 +
    pthread_mutex_unlock(&daemons_mutex_);
 +
}
  
 +
/* Daemon finish function. */
 +
static void daemon_finish(Daemon * daemon) {
 +
    int oldstate;
 +
    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate);
  
−
     /* This daemon is not in the list of daemons anymore,
+
     daemons_join_(1);
−
      and therefor can't be joined, except if acively cancelled. */
 
−
    if (!daemon->inJoin_)
 
−
        pthread_detach(pthread_self());
 
  
 +
    pthread_mutex_lock(&daemons_mutex_);
 +
    daemon->finished_ = 1;
 
     pthread_mutex_unlock(&daemons_mutex_);
 
     pthread_mutex_unlock(&daemons_mutex_);
  
−
     free(daemon);
+
     pthread_setcancelstate(oldstate, NULL);
−
 
 
 
}
 
}
  
 
static void * daemon_func(Daemon * daemon) {
 
static void * daemon_func(Daemon * daemon) {
−
     pthread_cleanup_push((void (*)(void *))daemon_terminate, daemon);
+
     pthread_cleanup_push((void (*)(void *))daemon_finish, daemon);
  
 
     daemon->func_();
 
     daemon->func_();
Line 82: Line 108:
 
   Start the "Daemon". */
 
   Start the "Daemon". */
 
static void daemon_create_(void (*func)(void)) {
 
static void daemon_create_(void (*func)(void)) {
−
     Daemon * daemon = malloc(sizeof(Daemon));
+
     Daemon * daemon   = malloc(sizeof(Daemon));
−
     daemon->func_   = func;
+
     daemon->func_     = func;
−
     daemon->inJoin_ = 0;
+
     daemon->finished_ = 0;
  
 
     pthread_mutex_lock(&daemons_mutex_);
 
     pthread_mutex_lock(&daemons_mutex_);
Line 96: Line 122:
 
     firstDaemon_ = daemon;
 
     firstDaemon_ = daemon;
 
     ++ daemons_;
 
     ++ daemons_;
 +
 +
    pthread_attr_t attr;
 +
    pthread_attr_init(&attr);
 +
    pthread_attr_setdetachstate(&attr, 0);
 +
    pthread_create(&daemon->hd_, NULL, (void *(*)(void *))daemon_func, daemon);
 +
    pthread_attr_destroy(&attr);
  
 
     pthread_mutex_unlock(&daemons_mutex_);
 
     pthread_mutex_unlock(&daemons_mutex_);
−
 
−
 
−
    pthread_create(&daemon->hd_, NULL, (void *(*)(void *))daemon_func, daemon);
 
 
}
 
}
  
−
/* Ask all registered daemons for termination and join them. */
+
/* Ask all registered daemons for cancellation and join them. */
−
static void daemons_join_(void) {
+
static void daemons_cancelAndJoin_(void) {
 
     fprintf(stderr, "Joining daemons ... ");
 
     fprintf(stderr, "Joining daemons ... ");
  
 
     pthread_mutex_lock(&daemons_mutex_);
 
     pthread_mutex_lock(&daemons_mutex_);
−
     while (firstDaemon_) {
+
    Daemon * daemon = firstDaemon_;
−
         pthread_t hd;
+
     while (daemon) {
−
        memcpy(&hd, &firstDaemon_->hd_, sizeof(pthread_t));
+
         my_pthread_cancel(daemon->hd_);
−
        firstDaemon_->inJoin_ = 1;
 
−
 
 
−
        pthread_mutex_unlock(&daemons_mutex_);
 
−
 
 
−
        // We may want to cancel a thread actively during termination:
 
−
        my_pthread_cancel(hd);
 
 
         // respectively
 
         // respectively
 
         //pthread_kill();
 
         //pthread_kill();
  
−
        my_pthread_join(hd, NULL);
 
 
         fprintf(stderr, "# ");
 
         fprintf(stderr, "# ");
  
−
         pthread_mutex_lock(&daemons_mutex_);
+
         daemon = daemon->next_;
 
     }
 
     }
 
     pthread_mutex_unlock(&daemons_mutex_);
 
     pthread_mutex_unlock(&daemons_mutex_);
  
 +
    daemons_join_(0);
 
     fprintf(stderr, "done\n");
 
     fprintf(stderr, "done\n");
 
}
 
}
Line 232: Line 255:
 
int main(void) {
 
int main(void) {
 
     atexit(log_threads);
 
     atexit(log_threads);
−
     atexit(daemons_join_);
+
     atexit(daemons_cancelAndJoin_);
  
 
     main_activity_();
 
     main_activity_();

Revision as of 12:34, 28 September 2007

[cpp] // // gcc -Wall -g example.c -o main.bin -lpthread //

  1. include <stdlib.h>
  2. include <stdio.h>
  3. include <pthread.h>
  4. include <string.h>
  5. include <unistd.h>


void my_pthread_cancel(pthread_t thread) {

   int res;
   if ((res = pthread_cancel(thread))) {
       fprintf(stderr, "%s(%p) => %s\n", __PRETTY_FUNCTION__, (void*)thread, strerror(res));
       // There seems to be an issue on Linux with pthread_cancel,
       // returning an error in case "thread" has already terminated, 
       // though not joined.

// abort();

   }

}

void my_pthread_join(pthread_t th, void **thread_return) {

   int res;
   if ((res = pthread_join(th, thread_return))) {
       fprintf(stderr, "%s - %s\n", __PRETTY_FUNCTION__, strerror(res));
       abort();
   }

}


typedef struct Daemon Daemon;

struct Daemon {

   Daemon * previous_;
   Daemon * next_;
   void (*func_)(void);
   pthread_t hd_;
   int       finished_;

};

static pthread_mutex_t daemons_mutex_ = PTHREAD_MUTEX_INITIALIZER; static Daemon * firstDaemon_ = NULL; static unsigned int daemons_ = 0;


static void daemons_join_(int finished) {

   pthread_mutex_lock(&daemons_mutex_);
   Daemon * daemon = firstDaemon_;
   while (daemon) {
       Daemon * next = daemon->next_;
       if (!finished || daemon->finished_) {
           -- daemons_;
           
           if (daemon->next_)
               daemon->next_->previous_ = daemon->previous_;
           
           if (daemon->previous_)
               daemon->previous_->next_ = daemon->next_;
           
           if (firstDaemon_ == daemon)
               firstDaemon_ = daemon->next_;
           pthread_mutex_unlock(&daemons_mutex_);
           my_pthread_join(daemon->hd_, NULL);
           pthread_mutex_lock(&daemons_mutex_);
           daemon->hd_ = 0xffffffff;
           free(daemon);
           daemon = firstDaemon_;
       }
       else
           daemon = next;
   }
   pthread_mutex_unlock(&daemons_mutex_);

}

/* Daemon finish function. */ static void daemon_finish(Daemon * daemon) {

   int oldstate;
   pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate);
   daemons_join_(1);
   pthread_mutex_lock(&daemons_mutex_);
   daemon->finished_ = 1;
   pthread_mutex_unlock(&daemons_mutex_);
   pthread_setcancelstate(oldstate, NULL);

}

static void * daemon_func(Daemon * daemon) {

   pthread_cleanup_push((void (*)(void *))daemon_finish, daemon);
   daemon->func_();
   pthread_cleanup_pop(1);
   return NULL;

}

/* Create a "Daemon" struct and register it.

  Start the "Daemon". */

static void daemon_create_(void (*func)(void)) {

   Daemon * daemon   = malloc(sizeof(Daemon));
   daemon->func_     = func;
   daemon->finished_ = 0;
   pthread_mutex_lock(&daemons_mutex_);
   daemon->previous_ = NULL;
   daemon->next_ = firstDaemon_;
   if (firstDaemon_) 
       firstDaemon_->previous_ = daemon;
   firstDaemon_ = daemon;
   ++ daemons_;
   pthread_attr_t attr;
   pthread_attr_init(&attr);
   pthread_attr_setdetachstate(&attr, 0);
   pthread_create(&daemon->hd_, NULL, (void *(*)(void *))daemon_func, daemon);
   pthread_attr_destroy(&attr);
   pthread_mutex_unlock(&daemons_mutex_);

}

/* Ask all registered daemons for cancellation and join them. */ static void daemons_cancelAndJoin_(void) {

   fprintf(stderr, "Joining daemons ... ");
   pthread_mutex_lock(&daemons_mutex_);
   Daemon * daemon = firstDaemon_;
   while (daemon) {
       my_pthread_cancel(daemon->hd_);
       // respectively
       //pthread_kill();
       fprintf(stderr, "# ");
       daemon = daemon->next_;
   }
   pthread_mutex_unlock(&daemons_mutex_);
   daemons_join_(0);
   fprintf(stderr, "done\n");

}


static unsigned int activities_ = 1; // The "main" thread is the first "activity". static pthread_mutex_t activity_mutex_ = PTHREAD_MUTEX_INITIALIZER;

static void activity_terminate_(void) {

   int use_exit = 0;
   pthread_mutex_lock(&activity_mutex_);
   -- activities_;
   use_exit = activities_ == 0;
   pthread_mutex_unlock(&activity_mutex_);
   // Terminate the process, if this was the last "activity"!
   if (use_exit) 
       exit(0);
   else
       pthread_exit(NULL);

}

static void * activity_func_(void (*func)(void)) {

   func();
   activity_terminate_();
   return NULL;

}

static void activity_create_(void (*func)(void)) {

   pthread_attr_t attr;
   
   /* Activities need to be detached. */
   pthread_attr_init(&attr);
   pthread_attr_setdetachstate(&attr, 1);
   
   pthread_t bt;
   pthread_create(&bt, &attr, (void *(*)(void *))activity_func_, func);
   pthread_attr_destroy(&attr);
   
   pthread_mutex_lock(&activity_mutex_);
   ++ activities_;
   pthread_mutex_unlock(&activity_mutex_);

}


/* Some daemon functions. */ static void log_threads(void) {

   fprintf(stderr, "activities: %u  daemons: %u\n", activities_, daemons_);

}

static void log_daemon_(void) {

   while (1) {
       log_threads();
       sleep(1); /* This is a cancellation point. */
   }
   pthread_exit(NULL);

}

static void some_daemon_(void) {

   int n = 10;
   while (n) {
       sleep(1);
       
       if (rand() < (RAND_MAX / (daemons_ + 1)))
           daemon_create_(some_daemon_);
       -- n;
   }

}

/* Some activity functions. */ static void some_activity_(void) {

   int n = 3;
   while (n) {
       sleep(1);
       
       if (rand() < (RAND_MAX / (activities_ + 1)))
           activity_create_(some_activity_);
       if (rand() < (RAND_MAX / (daemons_ + 1)))
           daemon_create_(some_daemon_);
       -- n;
   }

}

static void main_activity_(void) {

   srand (time (0));
   daemon_create_(log_daemon_);
   daemon_create_(some_daemon_);
   activity_create_(some_activity_);
   sleep(3);
   daemon_create_(some_daemon_);
   sleep(5);

}

int main(void) {

   atexit(log_threads);
   atexit(daemons_cancelAndJoin_);
   main_activity_();
   activity_terminate_();
   return 0;

}

Personal tools