c++封装多线程类

/*
内容：实现多线程类
引入：
1.经常需要在程序中启动一个或多个线程来处理任务，而如果每次都是去调用系统创建线程的API函数来创建，
代码量虽不多，但线程的创建和业务逻辑代码就揉在一起了，
2.创建多个线程的时候，有大量的重复代码，不便于维护。若我们把创建线程和销毁线程的这些共同的代码封装到一个类中，这样我们可以更专注业务逻辑的实现，
在其它地方直接拿来用就行，程序也便于维护和扩展。而且这样的话即使程序所使用的线程库更换了，
但线程类提供的接口没变，所以我们的业务逻辑代码也不用任何的改动。
实现：
创建一个线程也无非就是调用系统线程API或第三方库的API，然后传入线程函数地址和线程运行所需要的参数即可，所以我们需要将此部分代码抽象出来，并提供使用接口即可。
*/

/下面是自己实现的简单的多线程版本

【main函数】

#include "MyBaseThread.h"
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>


/*
// 在程序中使用如下
MyThread* pmt = new MyThread();
pmt->start();        //调用start()方法后，即启动了一个线程了


*/


#include <iostream>
using namespace std;


// 继承ZBaseThread类，并实现Run接口
class  MyThread : public BaseThread
{
public:
//只关心如何实现业务逻辑，而看不到线程是如何创建的
virtual void Run()
{
while(1)
{
cout << "hello，world" << endl;
sleep(1);
}

}
};


// 在程序中使用如下
int main()
{


// 最好用指针或者引用，这样就能实现多态
BaseThread* thread = new MyThread();

//调用start()方法后，即启动了一个线程了
thread->Create();



// 一定要调用线程阻塞函数，否则主线程退出后，子线程根本看不到
thread->WaitThreadExit();


return 0;
}

【h头文件】
#ifndef MY_BASE_THREAD_H
#define MY_BASE_THREAD_H


#include <iostream>
#include <pthread.h>
#include <stdio.h>
using namespace std;

class  BaseThread
{
    public:
        BaseThread();
        virtual  ~BaseThread();

bool Create();  // 创建线程  换回值：是否创建成功
void WaitThreadExit();  // 等待线程退出
/* 由继承类调用的纯虚函数， 处理实际线程 */


protected:

    private:  
virtual void Run() = 0; 
static void* RunFunc(void *pParam);  
         pthread_t threadId; // 线程id
};










#endif





【实现文件。cpp】

#include "MyBaseThread.h"


BaseThread::BaseThread()
  : threadId((pthread_t)0)
{     


}


BaseThread::~BaseThread()
{
  if (threadId != 0)
  {
  }
}


bool BaseThread::Create()
{
   int  retval;
   if (threadId != 0)
   {
   }
   
   retval = pthread_create(&threadId, NULL, RunFunc, this); // 线程属性设置成NULL


   if ( retval != 0 )
   {
       return false;
   }
   
   return true;
}


void BaseThread::WaitThreadExit()
{
     if (threadId != 0)
     {
          void * retval = NULL;
          pthread_join( threadId, &retval);
          threadId = 0;
     }
     else
     {
     }
}


void*  BaseThread::RunFunc(void *pParam)
{
// 这估计是这个类最精华的地方了
BaseThread* baseThread = (BaseThread *)pParam;

baseThread->Run();  // 这里设置了接口，用户要自己去实现该接口。该接口是线程处理函数

return NULL;
}

///下面是别人实现的//

//zthread.h

class   ZBaseThread
{
    public:
        ZBaseThread();
        virtual  ~ZBaseThread();
        /* 运行线程
         * @param policy  调度策略：  可以选择：
         *       SCHED_OTHER->缺省调度策略
         *       SCHED_FIFO->实时调度， 只有主动释放资源时或者更高优先级线程启动时才切换
         *       SCHED_RR-> 实时调度， 对相同优先级的线程采用时间片轮询方式调度
         * @param priority 优先级， 只有当调度策略为fifo或者rr时才生效
         * @return  true/false
         */
        virtual  bool RunThread( bool bCreateDetach = false, zint32  Policy = SCHED_OTHER, zint32 Priority = 0);
         /*
          * 设置线程运行参数， 可以实现实时调整线程优先级
          * @param Policy 调度 策略
          * @param priority  优先级
          * @return true/false
          */
         virtual bool SetThreadParam( zint32 Policy, zint32 Priority );
         /*
          *等待线程退出
          */
         virtual void WaitThreadExit();
         /*
          * 获取线程类型信息
          * @return 线程类型
          */
         virtual std::string GetTreadType();
    protected:
         /* 由继承类调用的纯虚函数， 处理实际线程 */
         virtual void OnThreadProc() = 0;
         static void * ZThreadRunTimeFunc( void * pParams);
        
         zuint32  m_RunningCounter;
         pthread_t m_hThread;
};