Thread.h

Go to the documentation of this file.

#ifndef thread_h
#define thread_h

#include <iostream>
#include <pthread.h>
#include <string>
#include <unistd.h>

// A thread start-up function

#define THREAD_START(fn) void* (fn)(void *arg)

// A thread shutdown function

#define THREAD_STOP(fn) void (fn)(void *arg)

// A thread cleanup function

#define THREAD_CLEAN(fn) void (fn)(void *arg)

// A method by which we can ping this thread

#define THREAD_PING(fn) void (fn)(void *arg)

// A pair of macros which we will use to safely lock/unlock a mutex.
// Also includes a fix to work-around the bug under kernel 2.4.20 that
// CORBA calls scramble the cancellation type.

#define INSTALL_MUTEX_CLEANUP(mutex, logStream) \
{\
  int oldtype;\
  if(pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &oldtype) != 0) \
    logStream.appendSysError(true, "pthread_setcanceltype");\
  pthread_cleanup_push(&Thread::unlockMutex, (void *) (&mutex));\
  if(oldtype != PTHREAD_CANCEL_DEFERRED && oldtype != PTHREAD_CANCEL_ASYNCHRONOUS) ;\
    oldtype = PTHREAD_CANCEL_ASYNCHRONOUS
 
#define UNINSTALL_MUTEX_CLEANUP(logStream) \
  pthread_cleanup_pop(0);\
  if(pthread_setcanceltype(oldtype, NULL) != 0) \
    logStream.appendSysError(true, "pthread_setcanceltype");\
}

namespace gcp {
  namespace util {
    
    class Thread {
      
    public:
      
      void start(void* arg);
      
      void cancel();
      
      void ping(void* arg);
      
      void broadcastReady();
      
      void broadcastDone();
      
      void setRunState(bool state);
      
      bool matchName(std::string compname);
      
      std::string strName();
      
      Thread(THREAD_START(*startFn), 
         THREAD_CLEAN(*cleanFn), 
         THREAD_PING(*pingFn), 
         std::string name, 
         unsigned startOrder=0,
         unsigned cancelOrder=0);

      // Note that if you use this constructor, you will have to
      // specify the start and stop order

      Thread(THREAD_START(*startFn), 
         THREAD_CLEAN(*cleanFn), 
         THREAD_PING(*pingFn), 
         std::string name, 
         unsigned startOrder, 
         unsigned cancelOrder,
         int priority,
         int schedPolicy=SCHED_RR);

      ~Thread();
      
      bool isRunning();
      
      bool isPingable();
      
      void raise(int sigNo);
      
      static THREAD_CLEAN(unlockMutex);
      
      bool wasError_;
      
      inline unsigned startOrder() {
    return startOrder_;
      }
      
      inline unsigned cancelOrder() {
    return cancelOrder_;
      }
      
      void waitUntilReady();
      
      inline std::string name() {
    return name_;
      };
      
    private:
      
      unsigned startOrder_;
      unsigned cancelOrder_;
      
      pthread_attr_t  attr_;

      void* startupArg_;
      
      bool running_;
      
      pthread_mutex_t runningGuard_; 
      
      pthread_t id_; 
      
      struct CondVar {
    
    pthread_mutex_t guard;
    
    pthread_cond_t cond;
      };
      
      CondVar ready_;
      
      CondVar done_;
      
      std::string name_;
      
      void privateConstructor(THREAD_START(*startFn), 
                  THREAD_CLEAN(*cleanFn),
                  THREAD_PING(*pingFn), 
                  std::string name, 
                  unsigned startOrder, unsigned cancelOrder,
                  int priority,
                  int schedPolicy);
      
      static THREAD_START(startThread);
      
      static THREAD_CLEAN(cleanThread);
      
      THREAD_START(*userStartFn_);
      
      THREAD_CLEAN(*userCleanFn_);
      
      THREAD_PING(*userPingFn_);
      
      bool setRunStatePrivate(bool state);
      
    }; // End class Thread
    
  } // End namespace util
} // End namespace gcp


#endif