Boost::thread库的使用

阅读对象

本文假设读者有几下Skills

[1]在C++中至少使用过一种多线程开发库，有Mutex和Lock的概念。

[2]熟悉C++开发，在开发工具中，可以编译、设置boost::thread库。

环境

[1]Visual Studio 2005/2008 with SP1

[2]boost1.39/1.40

 

概要

经过实例介绍boost thread的使用方式，本文主要由线程启动、Interruption机制、线程同步、等待线程退出、Thread Group几个部份组成。

正文

线程启动

线程能够从如下三种方式启动：

第一种用struct结构的operator成员函数启动：

struct callable

{

   void operator()() {  这里略去若干行代码   }

};

 

这里略去若干行代码

 

Callable x;

Boost::thread t(x);

 

第二种以非成员函数形式启动线程

 void  func(int nP)

 {  这里略去若干行代码

}

这里略去若干行代码

Boost::thread  t(func,123);

第三种以成员函数形式启动线程

#include <boost/bind.hpp>

 

这里略去若干行代码

 

class testBind{

public:

  void testFunc(int i)

{

  cout<<”i=”<<i<<endl;

}

};

 

这里略去若干行代码

 

testBind tb;

boost::thread t(boost::bind(&testBind::testFunc,&tb,100));

Interruption机制

能够经过thread对象的interrupt函数，通知线程，须要interrupt。线程运行到interruption point就能够退出。

Interruption机制举例：

#include "stdafx.h"

#include <iostream>

#include <boost/thread.hpp>

using namespace std;

 

void f()

{

     for(int i=1;i<0x0fffffff;i++)

     {

         if(i%0xffffff==0)

         {

              cout<<"i="<<((i&0x0f000000)>>24)<<endl;

             cout<<"boost::this_thread::interruption_requested()="<<boost::this_thread::interruption_requested()<<endl;

              if(((i&0x0f000000)>>24)==5)

              {

                   boost::this_thread::interruption_point();

              }

         }

     }

}

 

int _tmain(int argc, _TCHAR* argv[])

{

     boost::thread t(f);

     t.interrupt();

     t.join();  //等待线程结束

     return 0;

}

 

t.interrupt();告诉t线程，如今须要interrupt。 boost::this_thread::interruption_requested()能够获得当前线程是否有一个interrupt请求。如有 interrupt请求，线程在运行至interruption点时会结束。 boost::this_thread::interruption_point();就是一个interruption point。Interruption point有多种形式，较经常使用的有 boost::this_thread::sleep(boost::posix_time::seconds(5));当没有interrupt请求 时，这条语句会让当前线程sleep五秒，如有interrupt requirement线程结束。

如何使线程在运行到interruption point的时候，不会结束，能够参考下面的例子：

#include "stdafx.h"

#include <iostream>

#include <boost/thread.hpp>

using namespace std;

 

void f()

{

     for(int i=1;i<0x0fffffff;i++)

     {

         if(i%0xffffff==0)

         {

              cout<<"i="<<((i&0x0f000000)>>24)<<endl;

 

             cout<<"boost::this_thread::interruption_requested()"<<boost::this_thread::interruption_requested()<<endl;

 

              if(((i&0x0f000000)>>24)==5)

              {

                   boost::this_thread::disable_interruption di;

                   {

                       boost::this_thread::interruption_point();

                   }

              }

         }

     }

}

 

int _tmain(int argc, _TCHAR* argv[])

{

     boost::thread t(f);

     t.interrupt();

     t.join();  //等待线程结束

 

     return 0;

}

 

 

注意boost::this_thread::disable_interruption这条语句的使用，它可使大括号内的interruption point不会中断当前线程。

线程同步

Boost提供了多种lock致使上手须要较长时间，仍是看下面线程同步的例子比较简单，相信在多数应用中足够：

 

直接使用boost::mutex的例子

static boost::mutex g_m;

这里略去若干行代码

g_m.lock();

须要锁定的代码

g_m.unlock();

这里略去若干行代码

if(g_m.try_lock())

{

须要锁定的代码

}

这里略去若干行代码

 

 

使用lock guard的例子

#include <iostream>

#include <string>

#include <boost/thread.hpp>

#include <boost/thread/mutex.hpp>

#include <boost/thread/locks.hpp>

 

using namespace std;

 

static boost::mutex g_m;

 

void f(string strName)

{

     for(int i=1;i<0x0fffffff;i++)

     {

         if(i%0xffffff==0)

         {

              boost::lock_guard<boost::mutex> lock(g_m);

              cout<<"Name="<<strName<<" i="<<((i&0x0f000000)>>24)<<endl;

         }

     }

}

 

int _tmain(int argc, _TCHAR* argv[])

{

     boost::thread t(f,string("inuyasha"));

     boost::thread t2(f,string("kagula"));

     boost::thread t3(f,string("kikyou"));

 

     {

         boost::lock_guard<boost::mutex> lock(g_m);

         cout<<"thread id="<<t.get_id()<<endl;

     }

 

     t.join();

     t2.join();

     t3.join();

 

     return 0;

}

 

 

使用unique lock的例子

#include <iostream>

#include <string>

#include <boost/thread.hpp>

#include <boost/thread/mutex.hpp>

#include <boost/thread/locks.hpp>

 

using namespace std;

 

static boost::mutex g_m;

 

void f(string strName)

{

     cout<<"Thread name is "<<strName<<"-----------------begin"<<endl;

     for(int i=1;i<0x0fffffff;i++)

     {

         if(i%0xffffff==0)

         {

              boost::unique_lock<boost::mutex> lock(g_m);

 

              cout<<"Name="<<strName<<" i="<<((i&0x0f000000)>>24)<<endl;

             

              lock.unlock();

         }

     }

     cout<<"Thread name is "<<strName<<"-----------------end"<<endl;

}

 

int _tmain(int argc, _TCHAR* argv[])

{

     boost::thread t(f,string("inuyasha"));

     boost::thread t2(f,string("kagula"));

     boost::thread t3(f,string("kikyou"));

 

     t.join();

     t2.join();

     t3.join();

 

     return 0;

}

同Lock_guard相比

[1]Unique lock中有owns lock成员函数，可判断，当前有没有被lock。

[2]在构造Unique Lock时能够指定boost::defer_lock_t参数推迟锁定，直到Unique Lock实例调用Lock。或采用下面的编码方式使用：

     boost::unique_lock<boost::mutex> lock(mut,boost::defer_lock);

     boost::unique_lock<boost::mutex> lock2(mut2,boost::defer_lock);

     boost::lock(lock,lock2);

[3]它能够和Conditoin_variable配合使用。

[4]提供了try lock功能。

 

 

若是线程之间执行顺序上有依赖关系，直接到boost官网中参考条件变量（Condition variables）的使用。官网关于Conditon Variables的说明仍是容易看懂的。

注意，使用一个不恰当的同步可能消耗掉1/2以上的cpu运算能力。

Thread Group

线程组使用示例，其中f函数在上面的例子已经定义

int _tmain(int argc, _TCHAR* argv[])

{

     boost::thread_group tg;

     tg.add_thread(new boost::thread(f,string("inuyasha")));

     tg.add_thread(new boost::thread(f,string("kagula")));

     tg.add_thread(new boost::thread(f,string("kikyou")));

     tg.join_all();

     return 0;

}

参考来源

http://blog.csdn.net/cedricporter/article/details/6909108

[1]www.boost.org

 

 

 

 

Boost.Thread可使用多线程执行可移植C++代码中的共享数据。它提供了一些类和函数来管理线程自己，还有其它一些为了实如今线程之间同步数据或者提供针对特定单个线程的数据拷贝。
头文件:
#include <boost/thread.hpp>

线程定义
boost::thread 类是负责启动和管理线程。每一个boost::thread对象表明一个单独的执行线程，是不可拷贝的。因为它是能够被移动到，因此它们能够被保存到会改变大小的容器中，而且从函数返回。这使得线程建立的详细信息能够被封装到一个函数中。
boost::thread make_thread();

void f()
{
 boost::thread some_thread = make_thread();
 some_thread.join();
}

启动线程
一个新的线程能够经过传递一个可被调用的类型对象来启动，这个对象能够不须要给构造器参数就被唤醒。对象被拷贝到内存，并 且在最新建立的线程上唤醒。若是对象不能被拷贝，boost::ref能够以引用的方式来传递给函数对象。在这种状况下，用户的boost.thread 必须确保对象的引用的生命期必须比最新建立的执行线程要长。

struct callable
{
    void operator()();
};

boost::thread copies_are_safe()
{
    callable x;
    return boost::thread(x);
} // x is destroyed, but the newly-created thread has a copy, so this is OK

boost::thread oops()
{
    callable x;
    return boost::thread(boost::ref(x));
} // x is destroyed, but the newly-created thread still has a reference
  // this leads to undefined behaviour

若是你用一个函数或者可调用的对象但愿建立一个boost::thread 的实例须要提供一些参数，这些能够经过给它的构造体传递另外的参数来办到。

void find_the_question(int the_answer);

boost::thread deep_thought_2(find_the_question,42);
参数被拷贝到内部线程结构里:若是须要传递一个引用，可使用boost::Ref，只是对可调用对象的引用。
没有指定限制传递的额外参数的数量。

线程中的异常
若是传入到boost::thread构造体的函数或者可调用的对象抛出了一个异常并且唤醒它的不是boosst::thread_interrupted类型，std::terminate()会被调用来结束这个线程。

等待
当表明一个执行线程的线程对象被破坏时，这个线程变成分离的，一旦它被分离，将会继续执行知道唤醒由构造体提供的函数或者可调用对象执 行结束，或者程序已经结束。线程也能够经过调用detach()成员函数来显示的分离。在这种情形下，线程对象将不在表示一个当前分离的线程，而是一个非 线程体。
为了等待一个线程执行完毕，必须使用join()和timed_join()成员函数。join()会阻塞调用的线程直到线程结束。若是 线程刚刚执行结束，或者它已经不表明一个线程，join()会当即返回。timed_join()也是相似的，可是调用它若是在指定的时间流逝后线程仍然 没有结束它也会返回。

中断
一个正在运行的线程能够经过调用相应的boost::thread对象的interrupt()成员函数来中断。当被中断的线程在下次 执行一个指定的中断点(或者若是它在同时执行一个的时候被锁)并开启中断时，在被中断的线程中就会抛出一个 boost::thread_interrupted异常。若是没有被捕获，这会致使结束被中断线程的执行。与其余异常同样，栈就会被释放，自动存储期对 象的析构体将会被执行。
若是一个线程须要避免被中断，能够建立一个boost::this_thread::disable_interruption实例。这个类的对象在构造体建立线程的时候禁止了中断，能够在析构体调用以前的任意地方恢复容许中断。
void f()
{
    // interruption enabled here
    {
        boost::this_thread::disable_interruption di;
        // interruption disabled
        {
            boost::this_thread::disable_interruption di2;
            // interruption still disabled
        } // di2 destroyed, interruption state restored
        // interruption still disabled
    } // di destroyed, interruption state restored
    // interruption now enabled
}

经过构造一个boost::this_thread::restore_interruption实例能够临时转换一个 boost::this_thread::disable_interruption实例形成的影响，只要在有问题的地方传递一个 boost::this_thread::disable_interruption对象。这会从新恢复中断状态到当 boost::this_thread_diable_interruption对象被构造时，而且在次禁止中断当 boost::this_thread::restore_interruption对象被破坏时。
void g()
{
    // interruption enabled here
    {
        boost::this_thread::disable_interruption di;
        // interruption disabled
        {
            boost::this_thread::restore_interruption ri(di);
            // interruption now enabled
        } // ri destroyed, interruption disable again
    } // di destroyed, interruption state restored
    // interruption now enabled
}
咱们能够经过调用boost::this_thread::interruption_enabled()来查询中断的状态。

预约义的中断点
如下函数当容许中断时可能会抛出boost::thread_interrupted异常。
boost::thread::join()
boost::thread::timed_join()
boost::condition_variable::wait()
boost::condition_variable::timed_wait()
boost::condition_variable_any::wait()
boost::condition_variable_any::timed_wait()
boost::thread::sleep()
boost::this_thread::sleep()
boost::this_thread::interruption_point()

线程IDboost::thread::id类能够用来标识一个线程。每一个运行的执行线程都有一个特有的ID，能够经过对应的boost::thread的get_id()成员函数来得到ID。