从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接口还不够简洁，下一篇会有一个比较好的改进。

posted  by  蚂蚁终结者