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

看下面一个小例子：

#include "stdafx.h"
#include <iostream>
#include <boost/thread.hpp>
using namespace std;#define PRINT_DEBUG(x) cout<< x <<endl;void wait(int seconds)
{  boost::this_thread::sleep(boost::posix_time::seconds(seconds));
}
void threadfun1()
{  for (int i = 0; i < 5; ++i)  {  wait(1);  PRINT_DEBUG(i);  }
}
void threadfun2()
{  try  {  for (int i = 0; i < 5; ++i)  {  wait(1);  PRINT_DEBUG(i);  }  }  catch (boost::thread_interrupted&)  {  PRINT_DEBUG("thread_interrupted");  }
}
void test_thread_wait1()
{  boost::thread t(&threadfun1);//join()方法是一个阻塞调用：它可以暂停当前线程，直到调用join()的线程运行结束。  t.join();
}
void test_thread_wait2()
{  boost::thread t(&threadfun2);  wait(3);  t.interrupt();  t.join();
}
void test_thread_wait3()
{  boost::thread t(&threadfun1);  // timed_join()方法同样也是一个阻塞调用：它可以暂停当前线程，  // 直到调用join()的线程运行结束或者超时  t.timed_join(boost::posix_time::seconds(3));
}
void test_thread_wait4()
{  boost::thread t(&threadfun2);  wait(3);  //当thread 与线程执行体分离时，线程执行体将不受影响地继续执行，  //直到运行结束，或者随主线程一起结束。  t.detach();  // 此时join无作用  t.join();  // t不再标识任何线程 {Not-any-thread}  assert(t.get_id() == boost::thread::id());
}  int _tmain(int argc, _TCHAR* argv[])
{test_thread_wait4();return 0;
}

一、创建一个线程

创建线程

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

放弃时间片

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

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

等待一个线程

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

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

#include <iostream>
#include <boost/thread/thread.hpp>
#include <boost/thread/xtime.hpp>struct MyThreadFunc {void operator( )( ) {// Do something long-running...}
} threadFun;int main( ) {boost::thread myThread(threadFun);// Create a thread that starts// running threadFunboost::thread::yield( );           // Give up the main thread's timeslice// so the child thread can get some work// done.// Go do some other work...myThread.join( );                  // The current (i.e., main) thread will wait// for myThread to finish before it returns}

l boost::thread

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

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

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

template<typename Callable>

thread(Callable func);

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

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

struct callable
{void operator()(void){std::cout << "In callable ..." << std::endl;}
};
boost::thread thread_call(struct callable);

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

B.全局函数.

void func()
{std::cout << "In fun..." << std::endl;
}
boost::thread thread_func(func);

C. 类成员函数

借助boost::bind 轻松实现

class thread_test
{public:void invoke(){std::cout << "In thread_test::invoke..." << std::endl;}
};
thread_test athread_test;
boost::thread thread_member_call(boost::bind(&thread_test::invoke,&athread_test));

D. 含参函数对象

void func_arg(int num)
{std::cout << "In func_arg ..." << " num=" << num << std::endl;
}
boost::thread thread_arg_bind(boost::bind(&func_arg,1012));
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,...))

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

#include <iostream>
#include <string>
#include <functional>
#include <boost/thread/thread.hpp>// A typedef to make the declarations below easier to read
typedef void (*WorkerFunPtr)(const std::string&);template<typename FunT,  // The type of the function being calledtypename ParamT>// The type of its parameter
struct Adapter {Adapter(FunT f, ParamT& p) : // Construct this adapter and set thef_(f), p_(&p) {}          // members to the function and its argvoid operator( )( ) { // This just calls the function with its argf_(*p_);        }
private:FunT    f_;ParamT* p_;  // Use the parameter's address to avoid extra copying
};void worker(const std::string& s) {std::cout << s << '\n';
}int main( ) {std::string s1 = "This is the first thread!";std::string s2 = "This is the second thread!";boost::thread thr1(Adapter<WorkerFunPtr, std::string>(worker, s1));boost::thread thr2(Adapter<WorkerFunPtr, std::string>(worker, s2));thr1.join( );thr2.join( );
}

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

BOOST库的未来：

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

【Boost】boost库中thread多线程详解1——thread入门与简介相关推荐

Clipper库中文文档详解
Clipper库中文文档详解简介 Clipper Library(以下简称为Clipper库或ClipperLib或Clipper)提供了对线段和多边形的裁剪(Clipping)以及偏置(offse ...
python中isnull_Python pandas库中的isnull()详解
问题描述 python的pandas库中有一个十分便利的isnull()函数,它可以用来判断缺失值,我们通过几个例子学习它的使用方法. 首先我们创建一个dataframe,其中有一些数据为缺失值. i ...
【Boost】boost库中thread多线程详解9——thread_specific_ptr线程局部存储
大多数函数都不是可重入的.这也就是说在某一个线程已经调用了一个函数时,如果你再调用同一个函数,那么这样是不安全的.一个不可重入的函数通过连续的调用来保存静态变量或者是返回一个指向静态数据的指针. 举例 ...
【Boost】boost库中thread多线程详解8——call_once仅运行一次
还有一个问题没有解决:如何使得初始化工作(比如说构造函数)也是线程安全的.比方说,如果一个引用程序要产生唯一的全局的对象,由于实例化顺序的问题,某个函数会被调用来返回一个静态的对象,它必须保证第一次被 ...
【Boost】boost库中thread多线程详解5——谈谈线程中断
线程不是在任意时刻都可以被中断的.如果将线程中函数中的sleep()睡眠等待去掉,那么即使在主线程中调用interrupt()线程也不会被中断.thread库预定义了若干个线程的中断点,只有当线程执行 ...
【Boost】boost库中thread多线程详解13——线程标识符
在boost中也有唯一标识线程的数据结构:thread::id. boost::thread thread_func(func); thread::id var_id = thread_func.ge ...
【Boost】boost库中thread多线程详解12——线程的分离与非分离
Boos::thread线程的默认属性为非分离状态,线程结束后线程标识符.线程退出状态等信息需要通过join方法回收. boost::thread thread_func(func); thread_ ...
【Boost】boost库中thread多线程详解11——线程的休眠和中断
boost::thread 中提供一个静态方法 void boost::thread::sleep(system_time const& abs_time); 线程将休眠直到时间超时. sle ...
【Boost】boost库中thread多线程详解10——condition条件变量
有的时候仅仅依靠锁住共享资源来使用它是不够的.有时候共享资源只有某些状态的时候才能够使用.比方说,某个线程如果要从堆栈中读取数据,那么如果栈中没有数据就必须等待数据被压栈.这种情况下的同步使用互斥体是 ...

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