thread库为C++增加了线程处理的能力，提供了简明清晰的线程、互斥量等概念。
使用thread库
#include <boost/thread>
using namespace boost;链接时，需要使用-lpthread选项来链接POSIX线程库。
时间功能
在多线程编程时，经常要用到超时处理，thread库V3使用了chrono库提供对时间的支持。
chrono库的时间概念与date_time库类似，在名称空间boost::chrono里提供了时分秒等概念，可以使用microseconds、milliseconds、seconds、minutes、hours等时间长度类表示超时的时间，用time_point表示某个确定时间点。
this_thread::sleep_for( chrono::seconds( 2 ) );
this_thread::sleep_until( chrono::system_clock::now() + chrono::seconds( 1 ) );互斥量
mutex对象在创建后就表示了一个互斥量，成员lock()用于线程阻塞等待直至获得互斥量的所有权；当线程使用完共享资源后应该及时使用unlock()解除对互斥量的锁定
mutex mu;
try {
mu.lock();
cout << "some operations" << endl;
mu.unlock();
} catch( ... ) {
mu.unlock();
}直接使用mutex的成员函数来进行锁定互斥量不够方便，而且在发生异常导致退出作用域等情况下很可能会忘记解除锁定；因此thread库又提供了一系列RAII型的lock_gurad类，辅助锁定互斥量。它们在构造时锁定互斥量，在析构时自动解锁。
mutex mu;
mutex::scoped_lock lock(mu);
cout << "some operations" << end;线程对象
注意：thread对象是不可拷贝的。
创建线程
线程可以认为是在进程的另一个空间里运行的一个函数；在传递参数时需要注意，thread使用的是参数的拷贝，因此要求可调用物和参数类型都支持拷贝构造。如果希望传递给线程引用值就需要使用ref库进行包装，同时必须保证被引用的对象在线程执行期间一直存在。启动线程
当成功创建了一个thread对象后，线程就立刻开始执行，thread不提供类似start()，begin()那样的方法。
mutex io_mu;
void printing( atomic_int& x, const string& str ) {
for( int i = 0; i < 5; ++i ) {
mutex::scoped_lock lock( io_mu );
cout << str << ++x << endl;
}
}
int main() {
atomic_int x;
thread（ printing, ref( x ), "hello" );
thread( printing, ref( x ), "boost" );
this_thread::sleep_for( chrono::seconds( 2 ) );
}join()
thread的成员函数joinable()可以判断thread对象是否标识了一个可执行的线程体，如果joinable()返回true，我们就可以调用成员函数join()或者try_join_for()/try_join_until()来阻塞当前线程：
join()一直阻塞等待，直到线程结束；
try_join_for()/try_join_until()阻塞线程，或者阻塞等待一定的时间，然后不管线程是否结束都返回。detach()
可以使用detach()将thread与线程执行体手动分离，此后thread对象不代表任何线程体，失去对线程体的控制。
thread t1( printing, ref( x ), "hello" );
t1.detach();
assert( t1.get_id() == thread::id() ); // t1不再标识任何线程- bind()和function
有时在thread的构造函数中写传递给调用函数的参数很麻烦，尤其是在使用大量线程对象的时候，这时可以使用Boost的bind和function库。
thread t3( bind( printing, ref( x ), "thread" );
function<void>()> f = bind( printing, ref( x ), "mutex" );
thread( f );other functions
get_id()：返回线程id对象；
native_handle()：获取线程handle的函数，返回类型是系统平台相关的；
yield()：指示当前线程放弃时间片，允许其他的线程运行；
sleep_for()/sleep_until()：让线程睡眠等待一小段时间；线程中断
interrupt()：要求线程中断执行；
interruption_requested()：检查县城是否被要求中断；
被中断的线程会抛出一个thread_interrupted异常，这个异常应该在线程执行函数里捕获并处理，如果线程不处理这个异常，那么默认的动作是终止线程。
void to_interrupt( atomic_int& x, const string& str ) {
try {
for( int i = 0; i < 5; ++i ) {
this_thread::sleep_for( chrono::seconds( 1 ) );
mutex::scoped_lock lock( io_mu );
cout << str << ++x << endl;
}
} catch( thread_interrupted& ) {
cout << "thread_interrupted" << endl;
}
}
int main() {
atomic_int x;
thread t( to_interrupt, ref( x ), "hello" );
this_thread::sleep_for( chrono::seconds( 2 ) );
t.interrupt();
assert( t.interruption_requested() );
t.join();
}程序运行的结果可能如下： hello1
hello2
thread_interrupted
线程组
thread库提供类thread_group用于管理一组线程。
成员函数create_thread()是一个工厂函数，可以创建thread对象并运行线程；也可以在外部创建线程，使用add_thread()加入到线程组；如果不需要某个线程，使用remove_thread()进行删除。
join_all()和interrupt_all()用来对所有线程进行等待或者中断。
thread_group tg;
tg.create_thread( bind( printing, ref( x ), "C++" );
tg.create_thread( bind( printing, ref( x ), "boost" );
tg.join_all();使用thread_group，我们可以为程序建立一个类似于全局的线程池
typedef singleton_default<thread_group> thread_pool;
thread_pool::instance().create_thread( ... );条件变量
条件变量是thread库提供的另一种用于等待的同步机制，可以实现线程间的通信；必须要与互斥量配合使用；等待另一个线程中的某个事件发生，然后线程才能继续执行。
- condition_variable
- condition_variable_any
使用方法：
1. 拥有条件变量的线程先锁定互斥量，然后循环检查某个条件，如果条件不满足，那么就调用条件变量的成员函数wait()等待直至条件满足；
2. 其他线程处理条件变量要求的条件，当条件满足时调用它的成员函数notify_one()或notify_all()，以通知一个或者所有正在等待条件变量的线程继续执行。
#include <stack>
class buffer {
private:
mutex mu;
condition_variable_any cond_ put;
condition_variable_any cond_get;
stack<int> stk;
int un_read, capacity;
bool is_full() {
return un_read == capacity;
}
bool is_empty() {
return un_read == 0;
}
public:
buffer( size_t n ):un_read( 0 ), capacity( n ) {}
void put( int x ) {
{
mutex::scoped_lock lock( mu );
while( is_full() ) {
{
mutex::scoped_lock lock( io_mu );
cout << "full waiting..." << endl;
}
cond_put.wait( mu );
}
stk.push( x );
++un_read;
}
cond_get.notify_one();
}
void get( int* x ) {
{
mutex::scoped_lock lock( mu );
while( is_empty() ) {
{
mutex::scoped_lock lock( io_mu );
cout << "empty waiting..." << endl;
}
cond_get.wait( mu );
}
--un_read;
*x = stk.pop();
}
cond_put.notify_one();
}
}buffer buf( 5 );
void producer( int ) {
for( int i = 0; i < n; ++i ) {
{
mutex::scoped_lock lock( io_mu );
cout << "put " << i << endl;
}
buf.put( i );
}
}
void consumer( int n ) {
int x;
for( int i = 0; i < n; ++ i ) {
buf.get( &x );
mutex::scoped_lock lock( io_mu );
cout << "get " << x << endl;
}
}int main() {
thread t1( producer, 20 );
thread t2( consumer, 10 );
thread t3( consumer, 10 );
t1.join();
t2.join();
t3.join();
}共享互斥量
共享互斥量shared_mutex允许线程获取多个共享所有权和一个专享所有权，实现了读写锁的机制，即多个读线程和一个写线程。
shared_mutex读锁定时使用shared_lock<shared_mutex>，写锁定时使用unique_lock<shared_mutex>。
class rw_data {
private:
int m_x;
shared_mutex rw_mu;
public:
rw_data():m_x( 0 ) {}
void write() {
unique_lock<shared_mutex> ul( rw_mu );
++m_x;
}
void read( int* x ) {
shared_lock<shared_mutex> sl( rw_mu );
*x = m_x;
}
}void writer( rw_data& d ) {
for( int i = 0; i < 20; ++i ) {
this_thread::sleep_for( chrono::milliseconds( 10 ) );
d.write();
}
}
void reader( rw_data& d ) {
int x;
for( int i = 0; i < 10; ++i) {
this_thread::sleep_for( chrono::milliseconds( 5 ) );
d.read( &x );
mutex::scoped_lock lock( io_mu );
cout << "reader: " << x << endl;
}
}int main() {
rw_data d;
thread_group pool;
pool.create_thread( bind( writer, ref( d ) ) );
pool.create_thread( bind( writer, ref( d ) ) );
pool.create_thread( bind( reader, ref( d ) ) );
pool.create_thread( bind( reader, ref( d ) ) );
pool.create_thread( bind( reader, ref( d ) ) );
pool.create_thread( bind( reader, ref( d ) ) );
pool.join_all();
}future
很多情况下线程不仅仅要执行一些工作，它还可能要返回一些计算结果，thread库使用future范式提供了一种异步操作线程返回值的方法。
int fab( int n ) {
if( n == 0 || n == 1 ) {
return 1;
}
return fab( n - 1 ) + fab( n - 2 );
}
int main() {
// package_task只接受无参函数，因此需要使用bind
packaged_task<int> pt( bind( fab, 10 ) );
future<int> f = pt.get_future();
// 启动线程计算，必须使用boost::move()来转移packaged_task对象
// 因为packaged_task是不可拷贝的
thread( boost::move( pt ) );
f.wait();
assert( f.is_ready() && f.has_value() );
cout << f.get();
}