boost-thread

1. boost::thread是一个noncopyable的对象，其拷贝构造函数被设定为私有.

class BOOST_THREAD_DECL thread

{

private:

    thread(thread&);

    thread& operator=(thread&);

    ....

public:

    thread();

    ~thread();

};

2. 在使用thread的时候，一定要注意functor的作用域是否同thread对象保持一致，如果functor的作用域生命周期小于thread对象，那么系统可能会出现无法预期的结果

struct callable
{
    void operator()();
};
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
3. interruption: boost::thread支持在运行以下的函数的线程中实现interruption:

• 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()
 一旦运行线程接受到interruption的命令，就会throw exception boost::thread_interrupted， 可以在线程中通过定义boost::this_thread::disable_interruption变量来实现禁止响应interruption。而在申明禁止响应interruption的作用域中可以通过定义boost::this_thread::restore_interruption来enable响应interruption。

4. 判断一个thread的instance是否有效的方法是判断其thread_id是否有效，函数thread::get_id()获得运行线程的id，如果其不等于thread::id()那么就表明这个thread的instance是有效的，反之是无效的。

 

5. boost::thread支持4种lock类型的concept:

  * Lockable: 拥有独占锁

  * TimedLockable: Lockable + 获取锁超时机制

  * SharedLockable: TimedLockable + 支持共享锁机制(multi-read & single-write)

  * Upgrade-Lockable: SharedLockable + 支持锁的属性在独占锁&共享锁之间切换。

 

6. boost::thread支持的lock type:

  * lock_guard: 支持Lockable类型的对象，使用RAII方式来实现lock/unlock

  * unique_lock: 既支持RAII方式的lock，也支持非RAII方式的lock(在lock函数显示的调用时才获得lock)，还支持TimedLockable概念的lock，但是在调用析构函数的时候，将会释放所有的被占用的lock

  * shared_lock: 同unique_lock, 唯一的区别是仅仅支持SharedLockable概念的lock, 在lock/unlock过程中调用了lock_shared() / unlock_shared()

  * upgrade_lock: 同shared_lock, 唯一的区别是仅仅支持Upgrade-Lockable概念的lock, 在lock/unlock过程中调用了lock_upgrade() / unlock_upgrade()

 Note: 对于unique_lock/shared_lock/upgrade_lock都在constructor中支持3种不同的参数：

  * defer_lock_t的作用是在RAII之后不直接自动的调用lock函数，而是通过显示的调用lock函数来获得锁的所有权

  * try_to_lock_t的作用是在RAII的时候，调用try_lock, 无论能否获得锁，都返回

  * adopt_lock_t的作用是在RAII的时候，处理那些传入的mutex已经执行了lock操作而不需要重复执行的case。

 

7. boost::thread支持的mutex类型：

  * mutex: 一种Lockable概念的实现方式

  * timed_mutex: 一种TimedLockable概念的实现方式

  * recursive_mutex: 同mutex，但是同一个线程可以很多次的获得锁的所有权，通过reference_count来实现

  * recursive_timed_mutex:同timed_mutex, 但是同一个线程可以很多次的获得锁的所有权，通过reference_count来实现

  * shared_mutex: 一种UpgradeLockable概念的实现方式

 

8. One-time Initialization: 通过初始化变量boost::once_flag为BOOST_ONCE_INIT，同时使用call_once，来实现一个函数只在运行过程中被调用1次

 

9. barrier: 用于多线程之间的同步，最典型的用法是多线程中的每一个线程都执行到某一行code时，执行快的等待执行慢的，等到所有的相关线程都执行到这个点之后，才开始一起往下继续执行。

 

10. futures & promise: 它提供了一种获得结果的方式，这个结果可能在别的线程中计算，或者通过callback函数来实现，它的实现理念是通过异步的方式获得运行结果，必要的时候可以实现同步等待。其构成为：

 * boost::unique_future: 用于异步结果的获取。用于保存一个结果
 * boost::shared_future: 用于异步结果的获取。可用于保存多个结果

 * boost::packaged_task: 用于产生异步结果。用来wrap运行函数，或者functor，最终将函数或者functor的结果通知future。支持callback获得运行结果

 * boost::promise: 用于产生异步结果。不涉及到函数的运行，future监控promise的保存运行结果的变量，如果某一个线程将运行结果保存在promise的变量中，那么future就能够获得。支持callback获得运行结果