从Win32 API封装Thread类[1]

从Win32 API封装Thread类[1]

前几天在学Windows多线程程序设计，发现Win32 API用起来确实不怎么方便，特别是对于C++程序员。于是实现了一个简单的封装，技术含量当然不高，不过用起来还是比较方便的。如果你熟悉Java，你会发现这个实现有点像Java的Thread，在Java中有两种方法可以创建一个Thread：

1.从Thread类继承并实现run方法：

1  class  MyThread  extends  Thread {
2       public   void  run() {
3          ...
4      } 
5  };
6 
7  // 开启线程
8  MyThread thread  =   new  MyThread;
9  thread.start();

2.声明一个类实现Runnable接口并实现run方法：

1  class  MyRunnable  implements  Runnable {
2       public   void  run() {
3          ...
4      }
5  };
6 
7  //  开启线程 
8  MyThread thread  =   new  MyThread( new  MyRunnable);
9  thread.start();

具体实现
Java的实现方式还算优雅，我们也可以在C++中模拟，由于篇幅所限，在这里我们只关注基本功能的实现：
thread.h

 1  #ifndef THREAD_H
 2  #define THREAD_H
 3 
 4  #include  < windows.h >
 5 
 6  #define CLASS_UNCOPYABLE(classname) \
 7       private : \
 8      classname( const  classname & ); \
 9      classname &  operator = ( const  classname & );
10 
11  struct Runnable {
12      virtual  void  run()  =   0 ;
13      virtual  ~ Runnable() {}
14  };
15 
16  class  Thread :  public  Runnable {
17      CLASS_UNCOPYABLE(Thread)
18  public :
19      explicit Thread(Runnable * target  =   0 );
20      virtual  ~ Thread();
21      virtual  void  run() {}
22       void  start();
23       void  join();
24  private :
25       static  unsigned __stdcall threadProc( void * param);
26  private :
27      Runnable * _target;
28      HANDLE _handle;
29  };
30 
31  #endif /* THREAD_H */

在上面的代码中我们先定义一个Runnable类，并为Runnable类添加纯虚函数run，需要特别注意的是Runnable类的虚析构函数，任何想要成为基类的class都应该声明析构函数为virtual。
Thread类直接继承自Runnable，CLASS_UNCOPYABLE(Thread) 这一行用宏声明Thread类不可拷贝，具体细节请看 考虑用Macro替换Uncopyable 。start成员函数和Java中的一样，用来开启一个线程，join成员函数用来阻塞当前线程直到开启的线程执行完毕。threadProc作为静态成员函数用来传递给_beginthreadex，至于为什么用_beginthreadex代替CreateThread请问Google。初步的实现都比较简单，直接贴上代码：
thread.cpp

 1  #include  " thread.h "
 2  #include  < process.h >   // for _beginthreadex
 3 
 4  Thread::Thread(Runnable * target  /* = 0 */ )
 5  :_target( target )
 6  ,_handle( 0 ) {
 7 
 8  }
 9 
10  Thread:: ~ Thread() {
11       if  (_handle  !=   0 )
12          CloseHandle(_handle);
13       if  (_target  !=   0 )
14          delete _target;
15  }
16 
17  void  Thread::start() {
18       if  (_handle  !=   0 )
19           return ;
20      unsigned id;
21      _handle  =  reinterpret_cast < HANDLE > (
22          _beginthreadex( 0 ,  0 , threadProc,  this ,  0 ,  & id)
23          );
24  }
25 
26  void  Thread::join() {
27       if (_handle  !=   0 ) {
28          WaitForSingleObject(_handle, INFINITE);
29          CloseHandle(_handle);
30          _handle  =   0 ;
31      }
32  }
33 
34  unsigned __stdcall Thread::threadProc( void * param) {
35      Thread * p  =  static_cast < Thread *> (param);
36       if  (p -> _target  !=   0 )
37          p -> _target -> run();
38       else
39          p -> run();
40       return   0 ;
41  }

下面是测试代码：
test.cpp

 1  #include  " thread.h "
 2  #include  < iostream >
 3 
 4  using namespace std;
 5 
 6  // 第一种方法，从Thread类继承
 7  struct MyThread :  public  Thread {
 8      virtual  void  run() {
 9           for  ( int  i  =   0 ; i  <   5 ;  ++ i) {
10              cout  <<   " MyThread Running... "   <<  i  <<  endl;
11              Sleep( 100 );
12          }
13      }
14  };
15 
16  // 第二种方法，“实现”Runnable接口
17  struct MyRunnable :  public  Runnable {
18      virtual  void  run() {
19           for  ( int  i  =   0 ; i  <   5 ;  ++ i) {
20              cout  <<   " MyRunnable Running... "   <<  i  <<  endl;
21              Sleep( 300 );
22          }
23      }
24  };
25 
26  int  main() {
27 
28      MyThread thread1;
29      Thread thread2( new  MyRunnable());
30      thread1.start();
31      thread2.start();
32      thread1.join();
33      thread2.join();
34 
35       return   0 ;
36  }

可能的运行结果：
MyThread Running...0
MyRunnable Running...0
MyThread Running...1
MyThread Running...2
MyRunnable Running...1
MyThread Running...3
MyThread Running...4
MyRunnable Running...2
MyRunnable Running...3
MyRunnable Running...4

如果你熟悉boost库，你会知道boost库的Thread构造函数可以接受普通函数和函数对象作为参数，如果你觉得从Thread类继承或者实现Runnable接口还不够简洁，下一篇会有一个比较好的改进。