http://www.boost.org/doc/libs/1_35_0/doc/html/thread/synchronization.html Mutex概念線程同步最基本的是mutex（mutual exclusion的縮寫）。一個互斥體一次只允許一個線程訪問共享區。當一個線程想要訪問共享區時，首先要做的就是鎖?。╨ock）互斥體。如果其他的 線程已經鎖住了互斥體，那么就必須先等那個線程將互斥體解鎖，這樣就保證了同一時刻只有一個線程能訪問共享區域。
Boost.Thread supplies
recursive and
non-recursive mutexes with
exclusive ownership（獨占） semantics, along with a
shared ownership （共享） (multiple-reader / single-writer) mutex.
Boost.Thread supports four basic concepts for lockable objects:
Lockable,
exclusive ownership
TimedLockable,
SharedLockable,
This is the standard multiple-reader / single-write model:
at most one thread can have exclusive ownership, and if any thread does have exclusive ownership, no other threads can have shared or exclusive ownership. Alternatively, many threads may have shared ownership.
UpgradeLockable,
This is an extension to the multiple-reader / single-write model provided by the
SharedLockable concept:
a single thread may have
upgradable ownership at the same time as others have
shared ownership. The thread with
upgradable ownership may at any time attempt to upgrade that ownership to
exclusive ownership. If no other threads have shared ownership, the upgrade is completed immediately, and the thread now has
exclusive ownership, which must be relinquished by a call to
unlock(), just as if it had been acquired by a call to
lock().
[注：除Lockable的mutex外，其余的各種復雜mutex還需要更多代碼實踐]
Each mutex type implements one or more of these concepts, as do the
various lock types.
Lock Typesboost定義的Lock types為class template，以合適的Lockable object作為模板參數
lock_guard- RAII-style的簡單lock，在ctor中lock，在dtor中unlock
只支持簡單的Lockable object
unique_lock- 比
lock_guard復雜在：不僅提供RAII-style的lock，還允許用戶指定是否在ctor中立即lock，意味著可以指定推遲lock（defer acquiring the lock，通過指定defer_lock_t參數），直到顯式調用其lock()方法
還支持TimedLockable concept，前提是需要lock的Lockable object本身支持
The member functions of boost::unique_lock are not thread-safe...[注：這句沒看懂。。。]
shared_lockupgrade_lockupgrade_to_unique_lock
- [注：目前只用過unique_lock。后面幾種對應于不同需求的lock，從名字就可以直觀看出功能，還未試驗，直接參考api]
Mutex TypesMutex types對應于之前的mutex concepts，目前有：
適用于不同需求
Condition Variables The general usage pattern is that one thread locks a mutex and then calls
wait on an instance of
condition_variable or
condition_variable_any. When the thread is woken from the wait, then it checks to see if the appropriate condition is now true, and continues if so. If the condition is not true, then the thread then calls
wait again to resume waiting.(
中文參考)
lock is passed to
wait()；
wait() will
atomically add the thread to the set of threads waiting on the condition variable, and
unlock the mutex. When the thread is woken, the mutex will be
locked again before the call to
wait returns. This allows other threads to acquire the mutex in order to update the shared data, and ensures that the data associated with the condition is correctly synchronized.
In the mean time, another thread sets the condition to true, and then calls either notify_one() or notify_all() on the condition variable to wake one waiting thread or all the waiting threads respectively.
condition_variable_any比condition_variable更通用；condition_variable要求傳給wait()的必須是
boost::unique_lock<boost::mutex>類型；condition_variable一般更優化
One-time Initialization僅運行一次的例程
http://www.stlchina.org/twiki/bin/view.pl/Main/BoostThread#5%20%BD%F6%D4%CB%D0%D0%D2%BB%B4%CE%B5%C4%C0%FD%B3%CC
[注：還未使用過]
Barriers[注：還未使用過]