（十）boost库之多线程

（十）boost库之多线程

1、创建线程

使用boost库可以方便的创建一个线程，并提供最多支持9个参数的线程函数，相对于void*来说，方便了很多，创建线程主要提供了一下3种方式：

线程库头文件：#include <boost/thread.hpp>

a、使用全局函数作为线程执行体

void Func(int nCount)

{

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

    {

        cout <<  __FUNCTION__ << i << endl;

    }

}

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

{

    boost::thread th(Func, 100);

    //等待线程结束

    th.join();

}

b、使用成员函数作为线程执行体

class A

{

public:

    void Func(int nCount)

    {

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

        {

            cout <<  __FUNCTION__ << i << endl;

        }

    }

};

//线程参数都采用值传递，因此即使如下传入一个临时变量作为参数，线程照样可以正确运行

//如果需要传递引用，可通过ref库来实现

boost::thread *pth;

void TestThread()

{

    A a;

    //线程绑定一个局部变量

    pth = new boost::thread( &A::Func, &a, 100);

}

c、仿函数作为线程执行体

class  B

{

public:

    B(int n):nMem(n)

    {

    }

    void operator()()

    {

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

        {

            cout <<  __FUNCTION__ << i << endl;

        }

    }

    int nMem;

};

//线程thread对象销毁时，会与线程执行体分离，线程执行体不受影响

void TestThread2()

{

    //创建临时线程对象

    boost::thread(B(100));

}

结合以上方法，我们可以轻而易举的就创建一个线程，结合boost.bind库和lambda表达式，将会更方便。如：

boost::thread th3([](int nCount){

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

        {

            cout <<  __FUNCTION__ << i << endl;

        }

    }, 10);

2、中断线程

线程不是在任意时刻都可以被中断，因此要实现中断，需要我们自己决定什么时候可以被中断，boost库定义了以下函数是可以被中断的：

• boost::thread::join()
• boost::thread::timed_join()
• boost::boost::thread::try_join_for(),
• boost::boost::thread::try_join_until(),
• boost::condition_variable::wait()
• boost::condition_variable::timed_wait()
• boost::condition_variable::wait_for()
• boost::condition_variable::wait_until()
• boost::condition_variable_any::wait()
• boost::condition_variable_any::timed_wait()
• boost::condition_variable_any::wait_for()
• boost::condition_variable_any::wait_until()
• boost::thread::sleep()
• boost::this_thread::sleep_for()
• boost::this_thread::sleep_until()
• boost::this_thread::interruption_point()

成员函数interrupt，运行正在执行的线程中断，被中断的线程会抛出异常类boost::thread_interrupted，程序应该自行处理该异常，以确保线程正确结束。

void interrupt_thread(int nCount)

{

    try

    {

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

        {

            //sleep函数允许中断

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

            cout <<  __FUNCTION__ << i << endl;

        }

    }

    catch(boost::thread_interrupted&)

    {

        cout << "thread interrupt" << endl;

    }

}

boost::thread th2(interrupt_thread, 100);

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

th2.interrupt();

在以上中断函数中，除了最后一个，其它都是等待函数，如果想在非等待情况下，运行线程被中断，就可以使用最后一个函数。

比如我们可以将上面的boost::this_thread::sleep(boost::posix_time::seconds(1));替换成  boost::this_thread::interruption_point();

3、线程组

有时我们需要管理一组线程对象，进行统一的等待处理，使用boost::thread_group可以轻松的处理。

#include <boost/bind.hpp>

void ThreadGroup()

{

    boost::thread_group grp;

    grp.create_thread( boost::bind(Func, 10));

    A a;

    grp.add_thread(new boost::thread(&A::Func, &a, 100));

    grp.add_thread(new boost::thread(B(100)));

    grp.join_all();

}