线程就是，在同一程序同一时间内同意运行不同函数的离散处理队列。 这使得一个长时间去进行某种特殊运算的函数在运行时不阻碍其它的函数变得十分重要。 线程实际上同意同一时候运行两种函数，而这两个函数不必相互等待。

一旦一个应用程序启动。它仅包括一个默认线程。

此线程运行 main() 函数。 在
main()中被调用的函数则按这个线程的上下文顺序地运行。

这种程序称为单线程程序。

反之，那些创建新的线程的程序就是多线程程序。 他们不仅能够在同一时间运行多个函数，并且这在现在多核盛行的时代显得尤为重要。 既然多核同意同一时候运行多个函数，这就使得对开发者对应地使用这样的处理能力提出了要求。

然而线程一直被用来当并发地运行多个函数，开发者现在不得不细致地构建应用来支持这样的并发。 多线程编程知识也因此在多核系统时代变得越来越重要。

新建线程里运行的那个函数的名称被传递到 boost::thread 的构造函数。 一旦上述演示样例中的变量
t 被创建。该 thread() 函数就在其所在线程中被马上运行。 同一时候在
main() 里也并发地运行该 thread() 。

为了防止程序终止，就须要对新建线程调用 join() 方法。


join() 方法是一个堵塞调用：它能够暂停当前线程。直到调用 join() 的线程执行结束。

这就使得
main() 函数一直会等待到 thread() 执行结束。

正如在上面的样例中看到，一个特定的线程能够通过诸如 t 的变量訪问，通过这个变量等待着它的使用
join() 方法终止。 可是，即使 t 越界或者析构了。该线程也将继续运行。 一个线程总是在一開始就绑定到一个类型为
boost::thread 的变量，可是一旦创建。就不在取决于它。

甚至还存在着一个叫 detach() 的方法，同意类型为
boost::thread 的变量从它相应的线程里分离。 当然了。像
join() 的方法之后也就不能被调用。由于这个变量不再是一个有效的线程。

不论什么一个函数内能够做的事情也能够在一个线程内完毕。 归根结底，一个线程仅仅只是是一个函数，除了它是同一时候运行的。 在上述样例中，使用一个循环把5个数字写入标准输出流。

为了减缓输出，每个循环中调用
wait() 函数让运行延迟了一秒。

wait() 能够调用一个名为
sleep() 的函数，这个函数也来自于 Boost.Thread，位于
boost::this_thread 名空间内。

#include<iostream>

#include<boost/thread.hpp>



using namespace std;



void threadFunc(){

    cout<<"hello boost threads!"<<endl;

}



void wait(int seconds)

{

  boost::this_thread::sleep(boost::posix_time::seconds(seconds));

}



void thread()

{

  for (int i = 0; i < 5; ++i)

  {

    wait(1);

    std::cout << i << std::endl;

  }

}



struct ThreadFunc2{

    void operator()(const int & id){

        cout<<"thread #"<<id<<"hello boost Threads from operator!";

    }

};



int main(){

    boost::thread t(threadFunc);

    t.join();



    boost::thread t2(ThreadFunc2(),2);

    t2.join();



    boost::thread t3(thread());

    t3.join();



    return 1;

}

编译后输出：

hello boost threads!

thread #2hello boost Threads from operator!