Boost学习笔记 -- thread

thread库为C++增加了线程处理的能力，提供了简明清晰的线程、互斥量等概念。

使用thread库

#include 
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_pool;
thread_pool::instance().create_thread( ... );

条件变量

条件变量是thread库提供的另一种用于等待的同步机制，可以实现线程间的通信；必须要与互斥量配合使用；等待另一个线程中的某个事件发生，然后线程才能继续执行。

• condition_variable
• condition_variable_any

使用方法：
1. 拥有条件变量的线程先锁定互斥量，然后循环检查某个条件，如果条件不满足，那么就调用条件变量的成员函数wait()等待直至条件满足；
2. 其他线程处理条件变量要求的条件，当条件满足时调用它的成员函数notify_one()或notify_all()，以通知一个或者所有正在等待条件变量的线程继续执行。

#include 
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，写锁定时使用unique_lock。

class rw_data {
private:
    int m_x;
    shared_mutex rw_mu;

public:
    rw_data():m_x( 0 ) {}
    void write() {
        unique_lock ul( rw_mu );
        ++m_x;
    }
    void read( int* x ) {
        shared_lock 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();
}