从Win32 API封装Thread类[2]

从Win32 API封装Thread类[2]

在上一篇中介绍了创建Thread的两种方法：从Thread类继承或者实现Runnable接口。有时候这并不是特别方便，我们需要的是更灵活的方法，比如像boost库中的Thread一样可以用普通函数和函数对象
( functor and function object)作为构造函数参数。如果你熟悉STL，你应该熟悉bind1st和bind2nd这两个函数配接器( function adapter)，bind1st和bind2nd可以将一个二元函数( binary function)转换成一元函数( unary function)。为了使Thread类能够用普通函数和函数对象作为参数，我们需要一个bind将一元函数转换成无参函数：
bind.h

 1  #ifndef BIND_H
 2  #define BIND_H
 3 
 4 template <class _Result>
 5  struct trivial_function {
 6      typedef _Result result_type;
 7  };
 8 
 9 template <class _Operation>
10 class binder : public trivial_function<typename _Operation::result_type>  {
11 public :
12     binder(const _Operation &x, const typename _Operation::argument_type & y)
13          :op(x), value(y) {}
14     typename _Operation::result_type operator()() const  {
15         return  op(value);
16      }
17 protected :
18      _Operation op;
19      typename _Operation::argument_type value;
20  };
21 
22 template <class _Operation, class _Tp>
23 inline binder<_Operation>  
24 bind(const _Operation& __fn, const _Tp&  __x) 
25  {
26      typedef typename _Operation::argument_type _Arg_type;
27     return binder<_Operation> (__fn, _Arg_type(__x));
28  }
29 
30 #endif/*BIND_H*/

有了bind我们还需要修改Thread类的构造函数，显然我们必须将构造函数声明为成员模板(还有一种方法也可以达到同样的目的，就是把Thread类声明为模板，但是这样的设计好像不太好)，这样才能够让Thread类的构造函数可以接受各种类型的参数，修改后的构造函数应该能够使用如下三种类型的参数：
1.Runnable *
2.no argument function
3.no argument functor
下面是修改后的头文件：
runnable.h

 1  #ifndef RUNNABLE_H
 2  #define RUNNABLE_H
 3 
 4  struct Runnable {
 5     virtual void run() = 0 ;
 6     virtual ~ Runnable() {}
 7  };
 8 
 9 template <class T>
10 class RunnableFunctor : public  Runnable {
11 public :
12     RunnableFunctor(const T & f) :_func(f) {}
13     virtual void  run() { _func(); }
14 private :
15      T _func;
16  };
17 
18 //base template for no argument functor
19 template <class T>
20  struct FuncImpl {
21     static Runnable* transfer(const T & t) {
22         return new RunnableFunctor<T> (t);
23      }
24  };
25 
26 //partial specialization for T*
27 template <class T>
28 struct FuncImpl<T *>  {
29     static Runnable* transfer(T * t) {
30         return  t;
31      }
32  };
33 
34 //partial specialization for no argument function
35 template <class T>
36 struct FuncImpl<T (*)()>  {
37     static Runnable* transfer(T (* t)()) {
38         return new RunnableFunctor<T (*)()> (t);
39      }
40  };
41 
42 template <class T>
43 inline Runnable* transfer(const T & t) {
44     return FuncImpl<T> ::transfer(t);
45  }
46 
47 #endif/*RUNNABLE_H*/

thread.h

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

thread.cpp和前一篇的几乎一样，唯一的不同是去掉了构造函数Thread(Runnable *)，因为现在的构造函数改成了成员模板，实现也放在thread.h中了。现在的构造函数能够接受各种类型的参数，主要归功于模板函数transfer，实现代码在runnable.h中，主要技巧是用类的偏特化模拟函数模板的偏特化，不明白的请看 为什么不要特化函数模版。

下面是测试代码：
test.cpp

 1 #include "thread.h"
 2 #include <iostream>
 3 #include <functional>
 4 
 5  using namespace std;
 6 
 7 //no argument function
 8 void  print() {
 9     cout << "print" <<  endl;
10  }
11 
12 //unary function
13 void print1(int  n) {
14     cout << "print1" <<  endl;
15  }
16 
17 //binary function
18 void print2(int m, int  n) {
19     cout << "print2" <<  endl;
20  }
21 
22 
23 //no argument functor
24  struct PrintFunctor {
25     void operator()() const  {
26         cout << "PrintFunctor" <<  endl;
27      }
28  };
29 
30 //unary functor
31 struct PrintFunctor1 : public unary_function<int, void>  {
32     void operator()(int n) const  {
33         cout << "PrintFunctor1" <<  endl;
34      }
35  };
36 
37 //binary functor
38 struct PrintFunctor2 : public binary_function<int, int, void>  {
39     void operator()(int m, int n) const  {
40         cout << "PrintFunctor2" <<  endl;
41      }
42  };
43 
44 int  main() {
45 
46     //construct Thread with no argument function
47     Thread thread1(& print);
48      thread1.start();
49 
50     //construct Thread with unary function
51     Thread thread2(bind(ptr_fun(print1), 5 ));
52      thread2.start();
53 
54     //construct Thread with binary function
55     Thread thread3(bind(bind1st(ptr_fun(print2), 1), 2 ));
56      thread3.start();
57 
58 
59     //construct Thread with no argument functor
60      Thread thread4((PrintFunctor()));
61      thread4.start();
62 
63     //construct Thread with unary functor
64     Thread thread5(bind(PrintFunctor1(), 5 ));
65      thread5.start();
66 
67     //construct Thread with binary functor
68     Thread thread6(bind(bind1st(PrintFunctor2(), 1), 2 ));
69      thread6.start();
70 
71      thread1.join();
72      thread2.join();
73      thread3.join();
74      thread4.join();
75      thread5.join();
76      thread6.join();
77 
78     return 0 ;
79 }

当然了，上面的并不是全部，修改后的Thread类不仅能够使用原先的从Thread类继承或者实现Runnable接口的方法，还可以使用任何无参函数或无参函数对象。除了test.cpp里示范的，你甚至可以用bind,bind1st,bind2st,mem_fun,mem_fun_ref的组合来用某个类的成员函数作为参数，具有超强的灵活性。

目前实现的这些都是Thread类最基本的功能，其他功能如设置线程优先级，挂起或恢复线程，异常处理等具体实现都比较简单，这这里就不一一实现了。
源代码下载： 点击下载

posted by  蚂蚁终结者