---

mythread.h

Go to the documentation of this file.

//**************************************************************************
#ifndef _MYTHREAD_H_
#define _MYTHREAD_H_
//**************************************************************************
#include <sched.h>
#include <iostream.h>
#include "semaphore.h"
#include <pthread.h>
#include "misc.h"
//**************************************************************************
#ifndef _THREAD_SAFE
#define _THREAD_SAFE
#endif
//**************************************************************************
typedef void *(*void_t)(void *);
//**************************************************************************
class Thread
{
protected:
        virtual void RunMain(void *var = NULL) = 0;
        bool run_flag;

private:
        Semaphore *lock;
        int exit_flag;
        pthread_t threadID;
        pthread_attr_t attr;
        friend void Thread_ThreadRun(Thread *th);

public:
        void *vptr;

        Thread(Semaphore *sem = NULL, int pri = 10);
        void SetSemaphore(Semaphore *sem);
        virtual ~Thread() {Kill();};
        pthread_t ID() { return threadID; }
        bool isExit();
        void Exit();
        int StartMain(void *var = NULL);
        int Kill();
        bool isRunning();
        void SetPriority(int pri);
        Semaphore *Lock();
        
        int Wait();
        int Post();
};
//**************************************************************************
inline int Thread::StartMain(void *var)
{
vptr = var;
return pthread_create(&threadID, &attr, void_t(&Thread_ThreadRun), this);
}
//**************************************************************************
inline Thread::Thread(Semaphore *sem, int pri)
{
run_flag = false;
exit_flag = 0;
SetSemaphore(sem);
SetPriority(pri);
}
//**************************************************************************
inline void Thread::SetSemaphore(Semaphore *sem)
{
lock = sem;
}
//**************************************************************************
inline Semaphore *Thread::Lock()
{
return lock;
}
//**************************************************************************
inline bool Thread::isExit()
{
return (exit_flag == 1);
}
//**************************************************************************
inline void Thread::Exit()
{
exit_flag = 1;
if (!run_flag) return;

cout << "Waiting for thread to exit...." << flush;
while (run_flag) { mySleep(1000); }
cout << "done!" << endl << flush;
}
//**************************************************************************
inline int Thread::Kill()
{
if (!run_flag) return 0;

pthread_cancel(threadID);
run_flag = false;

return 1;
}
//**************************************************************************
inline bool Thread::isRunning()
{
return run_flag;
}
//**************************************************************************
inline int Thread::Wait()
{
return lock->Wait();
}
//**************************************************************************
inline int Thread::Post()
{
return lock->Post();
}
//**************************************************************************
inline void Thread::SetPriority(int pri)
{
struct sched_param sched;

pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

int policy = sched_getscheduler(0);
if (policy < 0)
        {
         sched_getparam(0, &sched);

         pri = sched.sched_priority - pri;
         if (pri > sched_get_priority_max(policy))
                pri = sched_get_priority_max(policy);

         if (pri < sched_get_priority_min(policy))
                pri = sched_get_priority_min(policy);

         sched.sched_priority = pri;
         pthread_attr_setschedpolicy(&attr, policy);
         pthread_attr_setschedparam(&attr, &sched);
        }
if(!pri)
        pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED);    
}
//**************************************************************************
inline void Thread_ThreadRun(Thread *th)
{
#ifndef __CYGWIN32__
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
#endif
th->run_flag = 1;
th->RunMain(th->vptr);
th->run_flag = 0;
}
//**************************************************************************
#define DEFINE_TEMPLATE_THREAD_CLASS(T, Etype) class T : public Thread {\
        private: void Run(Etype *v = NULL); \
                 void RunMain(void *v = NULL) { Run(reinterpret_cast<Etype*>(v)); } \
        public: T(Semaphore *sem = NULL, int pri = 0) : Thread(sem,pri) {}; \
                ~T() {Exit();} \
                int Start(Etype *v) {return StartMain(reinterpret_cast<void*>(v));} \
        }
//**************************************************************************
#define DEFINE_THREAD_CLASS(T) DEFINE_TEMPLATE_THREAD_CLASS(T, void)
//**************************************************************************
#endif  // _MYTHREAD_H_
//**************************************************************************

---