boost库中thread多线程详解1

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异常。

3.示例

[cpp] view plaincopyprint?

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