StarsunYzL

#include <iostream>
#include <functional>    // std::tr1::bind
#include <windows.h>
 
 
class MyThread
{
private:
  class ThreadDataBase
  {
  public:
    ThreadDataBase()
    {}
 
    virtual ~ThreadDataBase()
    {}
 
    virtual void Run() = 0;
  };
 
  // 用于保存线程相关的信息结构，这里只保存了MyThread构造函数
  // 时获得的F对象，一般是由bind返回的functor。
  // boost::thread类里的这个结构还保存了线程句柄等其它信息
  template <typename F>
  class ThreadData 
    : public ThreadDataBase
  {
  private:
    F f;
  public:
    ThreadData(F _f) : f(_f)
    {}
 
    void Run()
    {
      f();  // 调用functor
    }
  };
 
  // 线程句柄
  HANDLE m_hThread;
 
  // 因为不知道typename，所以不能定义ThreadData指针，所以建了个
  // 空基类，然后利用虚函数的特性调用派生类的Run()
  ThreadDataBase* pThreadData;
 
  // 线程中介函数，内部调用functor
  static DWORD CALLBACK ThreadProxy(LPVOID lpParam)
  {
    ThreadDataBase *pData = reinterpret_cast<ThreadDataBase*>(lpParam);
    pData->Run();
    delete pData;
    return 0;
  }
 
public:
  template <class F>
  explicit MyThread(F f)
    : pThreadData(new ThreadData<F>(f))    // 保存好functor
  {
    m_hThread = CreateThread(NULL, 0, &ThreadProxy, pThreadData, 0, NULL);
  }
 
  // 类似boost::thread::join()
  void Wait()
  {
    WaitForSingleObject(m_hThread, INFINITE);
  }
};
 
// 测试类
class Test
{
public:
  void TestThread(int nArg1, int nArg2)
  {
    std::cout << "Thread in class, Arg1 = " << nArg1 << ", Arg2 = " << nArg2 << std::endl;
  }
};
 
int main(int argc, char* argv[])
{
  Test test;
 
  // 使用类的非静态成员函数做线程函数
  // 而且类成员函数的返回类型和参数都没有限制
  MyThread thrd(std::tr1::bind(&Test::TestThread, &test, 123, 321));
  thrd.Wait();
 
  return 0;
}

std::tr1::bind(&Test::TestThread, &test, 123, 321)

class functor
{
public:
  void operator()
  {
    (&test)->TestThread(123, 321);
  }
};