实现线程的封装, 2种方式(面向对象，基于对象)

//实现线程的封装（面向对象）

//Noncopyable.h

#ifndef __WD_NONCOPYABLE_H__
#define __WD_NONCOPYABLE_H__
namespace wd
{
    class Noncopyable
    {
    protected:
        Noncopyable() {}
        ~Noncopyable(){}
    private:
        Noncopyable(const Noncopyable &);
        Noncopyable & operator=(const Noncopyable &d)   
    };
}//end of namespace wd

#endif

//Thread.h

#include "Noncopyable.h"
#include <pthread.h>
namespace wd
{
class Thread
: private Noncopyable//实现继承
//: public Noncopyable//接口继承
{
public:
    Thread();
    virtural ~Thread();
    virtural void run()=0;//纯虚函数接口
    void start();
    void join();
    static void * threadFunc(void * arg);
private:
    pthread_t _pthId;
    bool _isRunning;
} ;
}//end of namespace wd

//Thread.cc

#include "Thread.h"
#include <iostream>
using std::cout;
using std::endl;
namespace wd
{
Thread::Thread()
: _pthId(0)
, _isRuning(false)
{}
void Thread::start()
{
    pthread_create(&_pthId,NULL,threadFunc,this);
    _isRuning=true;
}
void Thread::join()
{
    if(_isRuning)
    {
        pthread_join(_pthId,NULL);
        _isRuning=false;
    }

}
void * Thread::threadFunc(void * arg)//静态成员函数
{
    Thread * p =static_cast<Thread*>(arg);
    if(p)
        p->run();
    return NULL; 
}
Thread::~Thread()
{
    if(_isRuning)
    {
        pthread_detach(_pthId)
    }
}
}//end of namespace wd

//testThread.cc

#include "Thread.h"
#include <unistd.h>
#include <stdlib.h>
#include <time.h>
#include <iostream>
#include <memory>
using std::cout;
using std::endl;
using std::unique_ptr;
class DerivedThread:public wd::Thread
{
public:
    virtual void run()
    [
        int cnt=20;
        srand(time(NULL));
        while(cnt--)
        {
            int number=rand()%100;
            cout<<"number="<<number<<endl;
            sleep(1);
        }
    ]
};
int main(void)
{
    unique_ptr<wd::Thread> p(new DerivedThread);//自动回收
    p->start();
    p->join();
    return 0;
}

//实现线程的封装（基于对象）

//Noncopyable.h

#ifndef __WD_NONCOPYABLE_H__
#define __WD_NONCOPYABLE_H__
namespace wd
{

class Noncopyable
{
protected:
Noncopyable(){}
~Noncopyable(){}
private:
Noncopyable(const Noncopyable &);
Noncopyable & operator=(const Noncopyable &);
};
}//end of namespace wd
#endif

//Thread.h

#include "Noncopyable.h"
#include <pthread.h>
#include <functional>
using std::function;
namespace wd
{
class Thread
: private Noncopyable// 实现继承
//: public Noncopyable//接口继承
{
typedef function<void()> ThreadCallback;
public:
Thread(ThreadCallback cb);
~Thread();
void start();
void join();
static void * threadFunc(void * arg);
private:
pthread_t _pthId;
bool _isRunning;
ThreadCallback _cb;//回调函数
};
}//end of namespace wd

//Thread.cc

#include "Thread.h"
namespace wd
{
Thread::Thread(ThreadCallback cb)
:_pthId(0)
,_isRunning(false)
,_cb(cb)
{}
void Thread::start()
{
pthread_create(&_pthId, NULL, threadFunc, this);
_isRunning = true;
}
void * Thread::threadFunc(void * arg)//静态成员函数
{
Thread * p = static_cast<Thread*>(arg);
if(p)
p->_cb();
return NULL;
}
void Thread::join()
{
if(_isRunning)
{
pthread_join(_pthId, NULL);
_isRunning = false;
}
}
Thread::~Thread()
{
if(_isRunning)
{
pthread_detach(_pthId);//将资源回收交给主线程进行托管
_isRunning = false;
}
}
}//end of namespace wd

//testThread.cc

#include "Thread.h"
#include <unistd.h>
#include <stdlib.h>
#include <time.h>
#include <iostream>
using std::cout;
using std::endl;
class Producer
{
public:
void func()//传一个函数对象
{
int cnt = 20;
::srand(::time(NULL));//设置随机数种子
while(cnt--)
{
int number = ::rand() % 100;
cout << "number = " << number << endl;
::sleep(1);//命名空间
}
}
};
int main(void)
{
wd::Thread thread(std::bind(&Producer::func, Producer()));

//通过bind直接传递,Producer()产生命名对象，复制

thread.start();
thread.join();
return 0;
}