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 sza {
  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);
      
      Thread(THREAD_START(*startFn), THREAD_CLEAN(*cleanFn), 
             THREAD_PING(*pingFn), std::string name, 
             unsigned startOrder, unsigned cancelOrder);

      ~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_;

      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);

      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 sza

#endif