boost库中thread多线程详解1——thread入门与简介

1. 概述

线程就是，在同一程序同一时间内允许执行不同函数的离散处理队列。 这使得一个长时间去进行某种特殊运算的函数在执行时不阻碍其他的函数变得十分重要。 线程实际上允许同时执行两种函数，而这两个函数不必相互等待。 一旦一个应用程序启动，它仅包含一个默认线程。 此线程执行main() 函数。 在main()中被调用的函数则按这个线程的上下文顺序地执行。 这样的程序称为单线程程序。 反之，那些创建新的线程的程序就是多线程程序。 他们不仅可以在同一时间执行多个函数，而且这在如今多核盛行的时代显得尤为重要。 既然多核允许同时执行多个函数，这就使得对开发人员相应地使用这种处理能力提出了要求。 然而线程一直被用来当并发地执行多个函数，开发人员现在不得不仔细地构建应用来支持这种并发。 多线程编程知识也因此在多核系统时代变得越来越重要。

2. 线程管理

2.1 情景1(test_thread_wait1)

在这个库最重要的一个类就是boost::thread，它是在boost/thread.hpp里定义的，用来创建一个新线程。下面的示例来说明如何运用它。 新建线程里执行的那个函数的名称被传递到boost::thread的构造函数。 一旦上述示例中的变量t 被创建，该 thread() 函数就在其所在线程中被立即执行。 同时在test_thread_wait1()里也并发地执行该 threadfun1() 。 为了防止程序终止，就需要对新建线程调用join() 方法。join() 方法是一个阻塞调用：它可以暂停当前线程，直到调用 join() 的线程运行结束。这就使得test_thread_wait1()函数一直会等待到 threadfun1()运行结束。 正如在上面的例子中看到，一个特定的线程可以通过诸如t的变量访问，通过这个变量等待着它的使用 join() 方法终止。 但是，即使 t 越界或者析构了，该线程也将继续执行。 一个线程总是在一开始就绑定到一个类型为 boost::thread 的变量，但是一旦创建，就不在取决于它。 甚至还存在着一个叫detach()的方法，允许类型为boost::thread 的变量从它对应的线程里分离。 当然了，像join()的方法之后也就不能被调用，因为这个变量不再是一个有效的线程。 任何一个函数内可以做的事情也可以在一个线程内完成。 归根结底，一个线程只不过是一个函数，除了它是同时执行的。 在上述例子中，使用一个循环把5个数字写入标准输出流。 为了减缓输出，每一个循环中调用wait() 函数让执行延迟了一秒。 wait() 可以调用一个名为sleep() 的函数，这个函数也来自于 Boost.Thread，位于 boost::this_thread 名空间内。 sleep() 要么在预计的一段时间或一个特定的时间点后时才让线程继续执行。 通过传递一个类型为boost::posix_time::seconds 的对象，在这个例子里我们指定了一段时间。 boost::posix_time::seconds 来自于Boost.DateTime库，它被 Boost.Thread 用来管理和处理时间的数据。 虽然前面的例子说明了如何等待一个不同的线程，但下面的例子演示了如何通过所谓的中断点让一个线程中断。

2.2 情景2(test_thread_wait2())

在一个线程对象上调用 interrupt() 会中断相应的线程。在这方面，中断意味着一个类型为boost::thread_interrupted的异常，它会在这个线程中抛出。然后这只有在线程达到中断点时才会发生。如果给定的线程不包含任何中断点，简单调用interrupt() 就不会起作用。每当一个线程中断点，它就会检查interrupt() 是否被调用过。只有被调用过了， boost::thread_interrupted 异常才会相应地抛出。Boost.Thread定义了一系列的中断点，例如sleep()函数。由于sleep()在这个例子里被调用了五次，该线程就检查了五次它是否应该被中断。然而sleep()之间的调用，却不能使线程中断。一旦该程序被执行，它只会打印三个数字到标准输出流。这是由于在test_thread_wait2()里3秒后调用 interrupt()方法。因此，相应的线程被中断，并抛出一个boost::thread_interrupted 异常。 这个异常在线程内也被正确地捕获，catch处理虽然是空的。由于thread() 函数在处理程序后返回，线程也被终止。这反过来也将终止整个程序，因为test_thread_wait2()等待该线程使用join()终止该线程。Boost.Thread定义包括上述 sleep()函数十个中断。有了这些中断点，线程可以很容易及时中断。然而，他们并不总是最佳的选择，因为中断点必须事前读入以检查boost::thread_interrupted异常。

看下面一个小例子：

[cpp] view plain copy

1. #include "stdafx.h"  
2. #include <iostream>  
3. #include <boost/thread.hpp>  
4. using namespace std;  
5.   
6. #define PRINT_DEBUG(x) cout<< x <<endl;  
7.   
8. void wait(int seconds)    
9. {    
10.     boost::this_thread::sleep(boost::posix_time::seconds(seconds));    
11. }    
12. void threadfun1()    
13. {    
14.     for (int i = 0; i < 5; ++i)    
15.     {    
16.         wait(1);    
17.         PRINT_DEBUG(i);    
18.     }    
19. }    
20. void threadfun2()     
21. {    
22.     try    
23.     {    
24.         for (int i = 0; i < 5; ++i)    
25.         {    
26.             wait(1);    
27.             PRINT_DEBUG(i);    
28.         }    
29.     }    
30.     catch (boost::thread_interrupted&)    
31.     {    
32.         PRINT_DEBUG("thread_interrupted");    
33.     }    
34. }    
35. void test_thread_wait1()    
36. {    
37.     boost::thread t(&threadfun1);  
38.     //join()方法是一个阻塞调用：它可以暂停当前线程，直到调用join()的线程运行结束。    
39.     t.join();    
40. }    
41. void test_thread_wait2()    
42. {    
43.     boost::thread t(&threadfun2);    
44.     wait(3);    
45.     t.interrupt();    
46.     t.join();    
47. }    
48. void test_thread_wait3()    
49. {    
50.     boost::thread t(&threadfun1);    
51.     // timed_join()方法同样也是一个阻塞调用：它可以暂停当前线程，    
52.     // 直到调用join()的线程运行结束或者超时    
53.     t.timed_join(boost::posix_time::seconds(3));    
54. }    
55. void test_thread_wait4()    
56. {    
57.     boost::thread t(&threadfun2);    
58.     wait(3);    
59.     //当thread 与线程执行体分离时，线程执行体将不受影响地继续执行，    
60.     //直到运行结束，或者随主线程一起结束。    
61.     t.detach();    
62.     // 此时join无作用    
63.     t.join();    
64.     // t不再标识任何线程 {Not-any-thread}    
65.     assert(t.get_id() == boost::thread::id());    
66. }    
67.   
68. int _tmain(int argc, _TCHAR* argv[])  
69. {  
70.     test_thread_wait4();  
71.   
72.     return 0;  
73. }  

一、创建一个线程

创建线程

    当一个thread执行完成时，这个子线程就会消失。注意这个线程对象不会消失，它仍然是一个还处在它的生存期的C++对象。同理，当对一个堆上的线程对象的指针调用delete时候，线程对象被销毁，操作系统的线程并不能保证就消失。

放弃时间片

    boost::thread::yield(); （暂时没有看出来它的实际作用）

    当前线程放弃余下的时间片。

等待一个线程

    myThread.join();（类似windows API WaitForSingleObject）

    调用这个方法的线程进入wait状态，直到myThread代表的线程完成为止。如果它不结束的话，join方法就不会返回。join是一个等待子线程结束的最好的方法。如果主程序不调用join方法而直接结束，它的子线程有可能没有执行完成，但是所有的子线程也随之退出。不调用join方法，主线程就不会等待它的子线程。

[cpp] view plain copy

1. #include <iostream>  
2. #include <boost/thread/thread.hpp>  
3. #include <boost/thread/xtime.hpp>  
4.    
5. struct MyThreadFunc {  
6.    void operator( )( ) {  
7.       // Do something long-running...  
8.    }  
9. } threadFun;  
10.    
11. int main( ) {  
12.    
13.    boost::thread myThread(threadFun);// Create a thread that starts  
14.                                       // running threadFun  
15.    
16.    boost::thread::yield( );           // Give up the main thread's timeslice  
17.                                       // so the child thread can get some work  
18.                                       // done.  
19.    
20.    // Go do some other work...  
21.    
22.    myThread.join( );                  // The current (i.e., main) thread will wait  
23.                                       // for myThread to finish before it returns  
24.    
25. }  

l boost::thread 

    boost::thread 是Boost库对thread的封装，隐藏了特定于操作系统的实现，提供给用户统一的接口，实现了跨平台，同时使用户从繁杂的thread的特定于操作系统的API中解脱出来，取而代之的是更易理解、更优美的对象。每个thread对象代表一个线程。

一． 使用boost::thread创建线程

由于每一个boost::thread对应一个线程，所以创建线程就是创建一个boost::thread对象。

template<typename Callable>

thread(Callable func);

这里需要一个函数对象（函数指针、仿函数）

A 仿函数（测试失败，不知道怎们回事回调不成功）

[cpp] view plain copy

1. struct callable  
2. {  
3.        void operator()(void)  
4.        {  
5.             std::cout << "In callable ..." << std::endl;  
6.        }  
7. };  
8. boost::thread thread_call(struct callable);  

[cpp] view plain copy

1. callable c;  
2. boost::thread thread_call(c);  //这样就可以了  

B.全局函数. 

[cpp] view plain copy

1. void func()  
2. {  
3.      std::cout << "In fun..." << std::endl;  
4. }  
5. boost::thread thread_func(func);  

C. 类成员函数

借助boost::bind 轻松实现

[cpp] view plain copy

1. class thread_test  
2. {  
3.       public:  
4.              void invoke()  
5.              {  
6.                   std::cout << "In thread_test::invoke..." << std::endl;  
7.              }  
8. };  
9. thread_test athread_test;  
10. boost::thread thread_member_call(boost::bind(&thread_test::invoke,&athread_test));  

D. 含参函数对象

[cpp] view plain copy

1. void func_arg(int num)  
2. {  
3.      std::cout << "In func_arg ..." << " num=" << num << std::endl;  
4. }  
5. boost::thread thread_arg_bind(boost::bind(&func_arg,1012));  
6. boost::thread thread_arg(func_arg,2012);  

Boost::thread 中重载的构造

template <class F,class A1,class A2,...>

thread(F f,A1 a1,A2 a2,...);

其实他内部也是通过boost::bind创建函数对象。

thread(boost::bind(f,a1,a2,...))

六、给线程函数传递一个参数

[cpp] view plain copy

1. #include <iostream>  
2. #include <string>  
3. #include <functional>  
4. #include <boost/thread/thread.hpp>  
5.    
6. // A typedef to make the declarations below easier to read  
7. typedef void (*WorkerFunPtr)(const std::string&);  
8.    
9. template<typename FunT,  // The type of the function being called  
10.          typename ParamT>// The type of its parameter  
11. struct Adapter {  
12.    Adapter(FunT f, ParamT& p) : // Construct this adapter and set the  
13.       f_(f), p_(&p) {}          // members to the function and its arg  
14.    
15.    void operator( )( ) { // This just calls the function with its arg  
16.       f_(*p_);          
17.    }  
18. private:  
19.    FunT    f_;  
20.    ParamT* p_;  // Use the parameter's address to avoid extra copying  
21. };  
22.    
23. void worker(const std::string& s) {  
24.    std::cout << s << '\n';  
25. }  
26.    
27. int main( ) {  
28.    
29.    std::string s1 = "This is the first thread!";  
30.    std::string s2 = "This is the second thread!";  
31.    
32.    boost::thread thr1(Adapter<WorkerFunPtr, std::string>(worker, s1));  
33.    boost::thread thr2(Adapter<WorkerFunPtr, std::string>(worker, s2));  
34.    
35.    thr1.join( );  
36.    thr2.join( );  
37. }  

使用这个函数适配器类模板，你就可以给线程函数传递参数了。如果你需要传递多个参数，仅需要在这个适配器中增加另一个类型和成员变量。

BOOST库的未来：

Boost线程库正在计划加入一些新特性。其中包括boost::read_write_mutex，它可以让多个线程同时从共享区中读取数据，但是一次只可能有一个线程向共享区写入数据；boost::thread_barrier，它使得一组线程处于等待状态，知道所有得线程都都进入了屏障区；boost::thread_pool,他允许执行一些小的routine而不必每一都要创建或是销毁一个线程。Boost线程库已经作为标准中的类库技术报告中的附件提交给C++标准委员会，它的出现也为下一版C++标准吹响了第一声号角。委员会成员对Boost线程库的初稿给予了很高的评价,当然他们还会考虑其他的多线程库。他们对在C++标准中加入对多线程的支持非常感兴趣。从这一点上也可以看出，多线程在C++中的前途一片光明。