Boost C++11多线程

https://www.boost.org/doc/libs/1_55_0/doc/html/thread.html

thread

• 当创建一个thread对象后，线程就立刻开始执行。
• join()和timed_join()方法等待线程结束。
  • join()一直阻塞等待，直到线程结束。
  • timed_join()阻塞等待线程结束，或阻塞等待一定的时间段，然后不管线程是否结束都返回。
• detach()与线程执行体分离，线程执行体不受影响的继续执行直到运行结束。
• 可以使用bind()和function库。
• thread类的3个静态成员函数：
  • yield() 指示当前线程放弃时间片，允许其他的线程运行。
  • sleep() 让线程睡眠等待一小段时间。
  • hardware_concurrency() 获得硬件系统可并行的线程数量，即CPU数量。
• thread::this_thread 子命名空间：
  • get_id() 获得线程ID
  • yield() 放弃时间片
  • sleep() 睡眠等待
  • at_thread_exit(func)函数，允许“登记”一个线程在结束的时候执行可调用物func，无论线程是否被中断。
• interrupt() 中断线程，允许正在执行的线程被中断，被中断的线程会抛出一个thread_interrupted异常。

创建线程4种方法以及分离或等待线程

在任何一个时间点上，线程是可结合的（joinable），或者是分离的（detached）。

void my_func()
{
	std::cout << "detach-分离 或 join-等待 线程" << std::endl;
}

TEST(BoostThread, detachOrjoin)//简单线程,线程状态joinable、detached
{
	boost::thread t(my_func);
	boost::thread::yield();//当前线程放弃余下的时间片。
	std::cout << t.joinable() << std::endl;
	t.join();

	boost::thread t1(my_func);
	std::cout << t1.joinable() << std::endl;
	t1.detach();
	std::cout << t1.joinable() << std::endl;
}

//线程的创建需要传递给thread对象一个可调用物（函数或函数对象），它必须具
//有operator()以供线程执行。
boost::mutex io_mutex;
struct count 
{
	count(int id) : id(id) { }

	void operator()()
	{
		for (int i = 0; i < 10; ++i)
		{
			boost::mutex::scoped_lock
				lock(io_mutex);
			std::cout << id << ": "
				<< i << std::endl;
		}
	}

	int id;
};

TEST(BoostThread, Typeobject)//复杂类型对象作为参数来创建线程
{
	boost::thread thrd1(count(1));
	boost::thread thrd2(count(2));
	thrd1.join();
	thrd2.join();
}

class HelloWorldStatic
{
public:
	static void hello()
	{
		std::cout <<
			"Hello world, I''m a thread!"
			<< std::endl;
	}
	static void start()
	{

		boost::thread thrd(hello);
		thrd.join();
	}

};

TEST(BoostThread, InClassStatic)//类内部创建线程
{
	HelloWorldStatic::start();//在这里start()和hello()方法都必须是static方法。
}

class HelloWorld
{
public:
	void hello()
	{
		std::cout <<
			"Hello world, I''m a thread!"
			<< std::endl;
	}
	void start()
	{
		boost::function0< void> f = boost::bind(&HelloWorld::hello, this);
		boost::thread thrd(f);
		thrd.join();
	}

};

TEST(BoostThread, InClass)//start()和hello()方法不是静态方法则采用此方法创建线程
{
	HelloWorld hello;
	hello.start();
}

class HelloWorldOut
{
public:
	void hello(const std::string& str)
	{
		std::cout << str;
	}
};

TEST(BoostThread, OutClass)
{
	HelloWorldOut obj;
	boost::thread thrd(boost::bind(&HelloWorldOut::hello, &obj, "Hello world, I''m a thread!" ) ) ;
	thrd.join();
}

线程的参数传递

void func1(const int &id)
{
	std::cout << "func1 id : " << id << std::endl;
}

struct MyThread
{
	void operator()(const int &id)
	{
		std::cout << "MyThread id : " << id << std::endl;
	}

	void func1(const int &id)
	{
		std::cout << "MyThread::func1 id : " << id << std::endl;
	}
};

TEST(BoostThread, Threadparameters)
{
	//普通函数  
	boost::thread t1(func1, 11);
	t1.join();

	//函数对象  
	MyThread myThread;
	boost::thread t2(myThread, 22);
	t2.join();

	//成员函数  
	boost::thread t3(&MyThread::func1, myThread, 33);
	t3.join();

	//临时对象  
	boost::thread t4(MyThread(), 44);
	t4.join();

	//对象引用  
	boost::thread t5(boost::ref(myThread), 55);
	t5.join();
}

还可使用bing与ref

线程中断

禁用于回复中断：
boost::this_thread::disable_interruption与boost::this_thread::restore_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
}

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::this_thread::interruption_requested()

类disable_interruption是一个RAII类型的对象，它在构造时关闭线程的中断，析构时自动恢复线程的中断状态。在disable_interruption 的生命期内线程始终是不可中断的，除非使用了restore_interruption 对象。

restore_interruption只能在disable_