linux下 C++ 封装一个简洁管理方便线程类

最近换了工作，发现旧代码使用直接使用linux api 线程API 代码难阅读而且管理不方便于是重新封装了一个线程类，不说那些多直接贴代码

thread.cpp

#include "thread.h"
void *threadBase::threadFun(void *arg){
    threadBase *p = (threadBase *)arg;
    while(!p->threadIsExit()){
       if(!p->threadLoop()){
            p->threadExit();
            break;
       }

       if(p->threadIsStop()){
            p->waitCond();
       }
    }
    p->threadEnd();
    return p;
}

void threadBase::run(){
    printf("run in\n");
    readyToRun();
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond, NULL);
    state = THREAD_RUNNING;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr,	PTHREAD_CREATE_DETACHED);
    pthread_create(&tid, &attr, threadFun, this);
    pthread_detach(tid); 
    printf("run out\n");
}

void threadBase::threadExit(){
    state = THREAD_EXIT;
    printf("threadExit \n");
}

bool threadBase::threadIsExit(){
    if(state == THREAD_EXIT){
        return true;
    }
    return false;
}

bool threadBase::threadIsStop(){
    if(state == THREAD_STOP){
        return true;
    }
    return false;
}

void threadBase::threadStop(){
    printf("threadStop \n");
    if(state == THREAD_RUNNING){
        state = THREAD_STOP;
    }
}

void threadBase::threadRerun(){
    if(state == THREAD_STOP){
        state = THREAD_RUNNING;
        sendCond();
    }
}



void threadBase::readyToRun(){
    printf("readyToRun\n");
}

void threadBase::readyToEnd(){
    printf("readyToEnd\n");
}

void threadBase::threadEnd(){
    readyToEnd();
    pthread_mutex_destroy(&mutex);	//销毁
    pthread_cond_destroy(&cond);	//销毁
    pthread_attr_destroy(&attr);
    printf("threadEnd out\n");
}

void threadBase::sendCond(){
    printf("sendCond in\n");
    pthread_cond_signal(&cond);//向条件变量发送信号
    printf("sendCond out\n");
}

void threadBase::waitCond(){
    printf("waitCond in\n");
    pthread_mutex_lock(&mutex);
    pthread_cond_wait(&cond, &mutex);
    pthread_mutex_unlock(&mutex);
    printf("waitCond out\n");
}

thread.h

#ifndef __THREAD_H__ 
#define __THREAD_H__ 

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>
using namespace std;
enum {
    THREAD_START = 0,
    THREAD_RUNNING,
    THREAD_STOP,
    THREAD_EXIT,
    THREAD_END
};

class threadBase{
    public:
        threadBase(){

        };
        int state = THREAD_START;
        virtual bool threadLoop() = 0;
        void run();
        void threadRerun();
        void threadStop();
        void threadExit();
        bool threadIsExit();
        bool threadIsStop();
    private:
        
        pthread_t tid;
        pthread_attr_t attr;

        pthread_mutex_t mutex  = PTHREAD_MUTEX_INITIALIZER; //定义互斥锁
        pthread_cond_t cond = PTHREAD_COND_INITIALIZER; //定义条件变量
        
    
        virtual void readyToRun();
        virtual void readyToEnd();

        static void *threadFun(void *arg);
        
        
        
        
        void threadEnd();
        
        void sendCond();
        void waitCond();
};




#endif /*__THREAD_H__*/

main.cpp

#include "thread.h"
#include <stdio.h>
using namespace std;

class test : public threadBase{//使用只需继承即可
   
   public:
   test(){

   };
   int i=0;
   bool threadLoop(){//线程循环
      i++;
      printf(" %d \n",i);
      usleep(20000);
      return true;
   }
   private:
    void readyToRun(){//线程开启前准备动作
        printf("readyToRuni\n");
    }
     void readyToEnd(){//线程结束准备动作
        printf("readyToEnd\n");;
     }
};

int main(){
   unsigned int i = 1;
   test *t = new test();
   t->run();
   while(!t->threadIsExit()){
      if(i==100){
         t->threadStop();
      }
      if(i == 200){
         t->threadRerun();
      }
      usleep(10000);
      i++;
      if(i==1000){
         t->threadExit();
      }
   }
   usleep(20000);
   delete t;
   return 0;
}

编译:g++ main.cpp thread.cpp -lpthread