封装Thread的两种方法 via C++ in Linux

方法一: 代理线程函数(proxyThreadFunc)作为类的静态成员函数, 回调函数指针作为类的私有成员变量

方法二: 代理线程函数(proxyThreadFunc)作为全局函数,  回调函数指针作为自定义结构体的成员

Noncopyable.h:

 #ifndef _Noncopyable_H_
 #define _Noncopyable_H_

 class Noncopyable
 {
 public:
     Noncopyable(){}
     ~Noncopyable(){}

 private:
     Noncopyable(const Noncopyable & a){}
     void operator=(const Noncopyable & a){}
 };

 #endif

Thread.h:

 #ifndef _Thread_H_
 #define _Thread_H_

 #include "Noncopyable.h"
 #include <functional>
 #include <pthread.h>

 /*====================
 ====================*/

 class Thread : public Noncopyable
 {
 public:
     typedef std::function<void ()> ThreadFunc;
     Thread(ThreadFunc func)
     :thread_id(), running_status(-), callback_func(func)
     {}
     virtual ~Thread()
     {
         if(!running_status)
             pthread_detach(thread_id);
     }

     virtual void start() = ;
     virtual void join() = ;

 protected:
     pthread_t thread_id;
     int running_status;
     ThreadFunc callback_func;
 };

 /*====================
 ====================*/

 class ThreadStruct : public Thread
 {
 public:
     ThreadStruct(ThreadFunc func)
     :Thread(func)
     {}
     ~ThreadStruct(){}

     virtual void start() override;
     virtual void join() override;
 };

 /*====================
 ====================*/

 class ThreadStatic : public Thread
 {
 public:
     ThreadStatic(ThreadFunc func)
     :Thread(func)
     {}
     ~ThreadStatic(){}

     virtual void start() override;
     virtual void join() override;

 private:
     static void * proxyThreadFunc(void *);
 };

 #endif

Thread.cpp:

 #include "Thread.h"

 /*====================
 ====================*/

 struct ThreadData
 {
     typedef Thread::ThreadFunc ThreadFunc;
     ThreadFunc cbfunc;

     ThreadData(ThreadFunc func)
     :cbfunc(func)
     {}

     void runThread()
     {
         cbfunc();
     }
 };

 void * proxyThreadFunc(void * arg)
 {
     ThreadData * pd = NULL;
     pd = static_cast<ThreadData *>(arg);
     pd->runThread();
     delete pd;
     return NULL;
 }    

 void ThreadStruct::start()
 {
     ThreadData * td = NULL;
     td = new ThreadData(callback_func);
     if(pthread_create(&thread_id, NULL, proxyThreadFunc, td) < )
         delete td;
 }

 void ThreadStruct::join()
 {
     pthread_join(thread_id, NULL);
 }

 /*====================
 ====================*/

 void * ThreadStatic::proxyThreadFunc(void * arg)
 {
     ThreadStatic * pd = NULL;
     pd = static_cast<ThreadStatic *>(arg);
     pd->callback_func();
     return NULL;
 }

 void ThreadStatic::start()
 {
     pthread_create(&thread_id, NULL, proxyThreadFunc, this);
 }

 void ThreadStatic::join()
 {
     pthread_join(thread_id, NULL);
 }

ThreadMain.cpp:

 #include "Thread.h"

 #include <iostream>
 #include <stdlib.h>
 #include <sys/socket.h>
 #include <unistd.h>

 using namespace std;

 class Test
 {
 public:
     void foo()
     {
         cout << "foo()" << endl;
     }

     void bar(int i)
     {
         cout << "bar(" << i << ")" << endl;
     }
 };

 /*====================
 ====================*/

 class TestThread
 {
 public:
     TestThread()
     :cnt(), pThread(NULL)
     {}

     void threadFunc()
     {
         while(cnt < )
         {
             sleep();
             cout << "cnt = " << ++cnt << endl;
         }
     }

     void start()
     {
         pThread->start();
     }

     void join()
     {
         pThread->join();
     }

     void attach(Thread * th)
     {
         pThread = th;
     }

 private:
     int cnt;
     Thread * pThread; //类的组合
 };

 /*====================
 ====================*/

 int main()
 {
     Thread * p1, * p2;
     TestThread tt;
     tt.attach(new ThreadStatic(bind(&TestThread::threadFunc, &tt)));
     Test test;
     p1 = new ThreadStruct(bind(&Test::foo, &test));
     p2 = new ThreadStatic(bind(&Test::bar, &test, ));

     tt.start();
     p1->start();
     p2->start();
     tt.join();
     p1->join();
     p2->join();
     delete p1;
     delete p2;
 }