在window环境下，实现类似std::thread的线程类

在window环境下，实现类似std::thread的线程类

zerglurker
      C++11中的std::thread是一个非常强大的线程类，但是这个线程类有一个很尴尬的地方，就是这个线程类创建的线程，其实用户是不可控的。

      比如：我要创建一个初始为暂停状态的线程。这个类就无法实现。再比如：我要在线程启动后，需要暂停，强制终结这个线程，也难以办到。又比如：我要在线程执行完成后，重新执行一次，也同样难以办到！std::thread类必须重新声明对象！

      这样这个玩意就难以用于实现线程池了，否则必须要频繁的启动和销毁线程，或者自己设计一个复杂的工作类！

      基于上面的问题，我只能自己设计一个线程类，来实现和std::thread类似的线程，但是又没有上述的问题。

      既然std::thread已经很不错了，我需要的是参考std::thread的实现，来实现自己的线程类即可。

      下面和各位分享一下我的实现过程：

            std::thread的核心只有两个部分构成：

            _Launch和bind，_Launch用于启动线程，bind用于构造线程函数，并适配各种输入参数和函数类型。

            另外std::thread用到了两个技巧：一是将构造函数声明为一个模板函数，以方便用户使用——这个技巧非常有意思，可以用于提升类的可复用性和自动适配能力；二是使用了可变参数模板——这个技巧使得其传入的线程函数没有固定的参数数量限制。

            可是看到这里坑爹的事情来了：std::thread将线程管理全部外包到_Launch，这怎么搞！我还指望它自己有什么线程管理呢！完全没有看到如何启动用户传入的函数啊！

            没有办法，只好继续看_Launch函数——STL模板库真心难看，这代码和命名写的，真心虐心，真心不想看啊

。

            _Launch函数构造了一个_LaunchPad本地对象，使用_Launch来启动线程，还是没有看到如何启动用户传入的函数！——好吧，到这里然并卵，只好捏着鼻子继续看。

            _LaunchPad实现了一个_Run函数，在_Run函数里面终于看到我想要的东西了


_Target _Local(_STD forward<_Target>(_Ln->_MyTarget));
_Ln->_Release();
_Local();//←←←就是这货！！！            这里补充一个知识点就是std::forward的含义。其实也没有什么特别的含义，就是将参数转为一个右值引用，类似于复制。
            区别在于forward不需要对象具有构造函数，可以直接使用对象的原值。防止在参数传递过程中，触发一些复制构造函数或者其他构造函数。

            回到std::thread的构造函数，这里的_Local其实是一个std::bind类型的数据

            看到这里，我终于明白该怎么做了，我只需要保存这个bind类型的数据，在我自己的线程函数里面去调用它的函数调用操作即可（即调用operator()）

            可是动手之后，又发现一个坑，怎么声明这个数据类型呢？

            bind本身是一个模板，直接声明，我的线程类也会变成一个模板类，那尼玛用起来就酸爽了（有毅力的童鞋可以去尝试一下）

            想了半天，突然想到一个办法：要构造一个自己的数据类型，基类提供一个operator()接口，方便子类去实现

            通过多态调用到子类的operator()接口，来完成函数调用！！

            到这里基本大的坑都填完了，不多废话了，下面直接上代码

            可变数据类型

class Data{
public:
Data(){ pData = NULL; }
~Data(){}
virtual void operator()() = 0;
void* pData;
};

template<class DataType>
class CMyData:public Data{
public:
CMyData() :
Data()
{
}
~CMyData(){
if (pData){
delete (DataType*)pData;
pData = NULL;
}
}
explicit CMyData(const DataType& d){
pData = (void*)new DataType(d);
}
virtual void operator()(){
if (pData != NULL){
DataType* pLocale = (DataType*)pData;
(*pLocale)();
}
}
};

            自定义线程类——不要介意名字和代码格式，这些都是细枝末节哈

class Test{
public:
template<class _Fn,
class... _Args>
explicit Test(_Fn&& _Fx, _Args&&... _Ax){
Init(
std::bind(
std::_Decay_copy(_STD forward<_Fn>(_Fx)),
std::_Decay_copy(_STD forward<_Args>(_Ax))...
)
);
}
template<class bindType>
void Init(bindType&& bindData){
_Data = new CMyData<bindType>(std::forward<bindType>(bindData));
if (_Data != NULL){
m_hThread = (HANDLE)_beginthreadex(NULL, 0, &Test::ThreadEntry, this, CREATE_SUSPENDED, &m_nThreadID);
}
}
virtual int Start(){
if ((m_hThread == INVALID_HANDLE_VALUE) || (m_hThread == NULL)){
return -1;
}
//if ((m_nStatus == TH_INIT) || (m_nStatus == TH_PAUSE))
{
if (ResumeThread(m_hThread) != 0){
return -2;
}
//m_nStatus = TH_RUNNING;
}
return 0;
}
private:
Data* _Data;
void ThreadFunc(){
if (_Data != NULL){
(*_Data)();
}
}
static unsigned __stdcall ThreadEntry(void* arg){
Test* pThread = (Test*)arg;
if (pThread){
pThread->ThreadFunc();
}
_endthreadex(0);
return 0;
}
//线程句柄
HANDLE m_hThread;
//线程ID
unsigned m_nThreadID;
};            测试代码
void test001(int argc, char**argv, char**env)
{
//CThreadImplement < func>;
std::thread th(func, argc, argv, env);
th.detach();
Test tt(func, argc, argv, env);
tt.Start();
getchar();
}

            测试结果如下，可以看到，两个版本的运行效果是一模一样的！