Boost C++ Libraries Home Libraries People FAQ More
PrevUpHomeNext

Synchronization同步處理

Mutex Concepts
Lock Types
Lock functions
Mutex Types
Condition Variables
One-time Initialization
Barriers
Lockable Concept
TimedLockable Concept
SharedLockable Concept
UpgradeLockable Concept

         互斥量對像簡化了線程間數據竟態保護和數據同步。一個線程通過一個鎖定函數取得一個互斥量的所有權，通過一個對應的解鎖函數釋放 所有權。互斥量可以是支持遞歸所有權的或非遞歸所有權的， 也可以同時屬於多個線程。 Boost.Thread 庫提供遞歸和非遞歸互斥量, 支持排他型的所有權和共享所有權(multiple-reader / single-writer)。

          Boost.Thread 庫支持四種基本的可所有權概念: Lockable, TimedLockable, SharedLockable 和UpgradeLockable。 每種互斥量依據自己的目標實現一種或多種概念。

void lock()
bool try_lock()
void unlock()

         Lockable concept 對排他型所有權建模。 實現 Lockable concept 概念需要提供下面的成員函數:

        通過 函數lock()或函數try_lock() 獲取的所有權需要通過 unlock()來釋放。

效果:

當前線程阻塞直到取得互斥量的所有權。

後置條件:

當前線程擁有該互斥量。

拋出:

如果出錯拋出boost::thread_resource_error異常。

效果:

嘗試取得互斥量所有權，線程不會被阻塞。

返回:

如果取得所有權返回true, 否則返回false 。

後置條件:

如果返回 true, 當前線程擁有該互斥量。

拋出:

如果出錯拋出boost::thread_resource_error異常。

前置條件:

前線程擁有該互斥量 。

效果:

當前線程釋放互斥量所有權。

後置條件:

前線程擁不擁有該互斥量。

拋出:

無

bool timed_lock(boost::system_time const& abs_time)
template<typename DurationType> bool timed_lock(DurationType const& rel_time)

         TimedLockable concept 概念細化了Lockable concept概念，支持嘗試獲取所有權時超時放棄。

         實現TimedLockable concept 概念的類型除了需要實現 Lockable concept概念。 還需要提供下面的成員函數：

        通過 函數timed_lock() 獲取的所有權需要通過 unlock()來釋放。

效果:

當前線程嘗試取得該互斥量所有權。 線程阻塞直到它獲得所有權, 或等待超過指定的時間點。 如果等待時間點已過, 函數的行為和 try_lock()一樣。

返回:

如果取得所有權返回true, 否則返回false。

後置條件:

如果返回 true, 當前線程擁有該互斥量。

拋出:

如果出錯拋出boost::thread_resource_error異常。

效果:

同 timed_lock(boost::get_system_time()+rel_time)。

void lock_shared()
bool try_lock_shared()
bool timed_lock_shared(boost::system_time const& abs_time)
void unlock_shared()

         SharedLockable concept 細化了TimedLockable concept允許共享所有權（ shared ownership）和排他型所有權（exclusive ownership）。 適用於標準的 multiple-reader / single-write模型: 通常一個線程可以獲取排他型所有權, 此時其他線程不能獲取到排他型所有權和共享型所有權, 相反的, 多個線程可以同時獲得共享所有權。

         如果一個類型要實現SharedLockable concept 概念, 除了需要滿足TimedLockable concept 概念要求, 還需要提供下面的成員函數:

       通過 函數 lock_shared(), try_lock_shared() 或 timed_lock_shared() 獲取的所有權需要通過unlock_shared()來釋放。

效果:

當前線程阻塞直到取得互斥量的共享所有權。

後置條件:

當前線程取得互斥量的共享所有權。

拋出:

如果出錯拋出boost::thread_resource_error異常。

效果:

當前線程嘗試取得該互斥量的共享所有權，線程不阻塞。

返回:

如果取得互斥量的共享所有權返回true, 否則返回false。

後置條件:

如果返回 true,  當前線程取得互斥量的共享所有權。

拋出:

如果出錯拋出boost::thread_resource_error異常。

效果:

當前線程嘗試取得該互斥量的共享所有權。 線程阻塞直到它獲得所有權, 或等待超過指定的時間點。 如果等待時間點已過, 函數的行為和 try_lock_shared()一樣 。

返回:

如果取得互斥量的共享所有權返回true, 否則返回false。。

後置條件:

如果返回 true,  當前線程取得互斥量的共享所有權。

拋出:

如果出錯拋出boost::thread_resource_error異常。

前置條件:

當前線程擁有互斥量的共享所有權。

效果:

釋放當前線程擁有的互斥量共享所有權。

後置條件:

當前線程不在擁有該互斥量共享所有權。

拋出:

無

void lock_upgrade()
void unlock_upgrade()
void unlock_upgrade_and_lock()
void unlock_upgrade_and_lock_shared()
void unlock_and_lock_upgrade()

         UpgradeLockable concept 是SharedLockable concept的細化，特點在於允許所有權升級到獨佔狀態。 這是對共享所有權支持的multiple-reader / single-write模型的一個擴展：一個線程可以擁有upgradable ownership而同時其他線程擁有共享所有權 該線程可以在任何時候試圖升級其所有權為獨佔式所有，如果此時沒有其他線程擁有共享所有權，升級立即完成, 該線程就會擁有獨佔所有權, 這個所有權需要通過 unlock()來釋放, 就像這個所有權是通過lock()取得一樣。

          如果該線程試圖升級到獨佔所有時,其他線程擁有對應的共享所有權, 升級會失敗，該線程阻塞直到其獲得獨佔所有權。

         UpgradeLockable concept中的所有權也可以降級: 獨佔式所有權可以降級為可升級所有權或者共享所有權,可升級所有權可以降級為一般共享所有權。

          如果一個類型要實現 UpgradeLockable concept概念，除了需要實現 SharedLockable concept概念, 它還需要提供下面的成員函數:

          通過函數lock_upgrade() 取得的所有權需要通過函數 unlock_upgrade()來釋放 。 如果所有權類型通過函數unlock_xxx_and_lock_yyy()改變 , 所有權必須通過新所有權對應的釋放函數來釋放。

效果:

當前線程阻塞知道它獲得可升級所有權。

後置條件:

當前線程取得該對象的可升級所有權。

拋出:

如果出錯拋出boost::thread_resource_error異常。

前置條件:

當前線程擁有該對象的可升級所有權。

效果:

釋放當前線程擁有的該對象的可升級所有權。

後置條件:

當前線程不在擁有該對象的可升級所有權。

拋出:

無

前置條件:

當前線程擁有該對象的可升級所有權。

效果:

當前線程自動釋放擁有的該對象可升級所有權，並試圖取得該對象的獨佔所有權, 線程阻塞直到其獲得獨佔所有權。

後置條件:

當前線程擁有該對象的獨佔所有權。

拋出:

無

前置條件:

當前線程擁有該對象的可升級所有權。

效果:

當前線程自動釋放擁有的該對象可升級所有權，取得共享所有權，該函數會立即返回。

後置條件:

當前線程擁有該對象的共享所有權。 

拋出:

無

前置條件:

當前線程擁有該對象的獨佔所有權。 。

效果:

當前線程自動釋放擁有的該對像獨佔級所有權，取得可升級所有權，該函數會立即返回。

後置條件:

當前線程自動擁有該對象可升級所有權。

拋出:

無

Class template lock_guard
Class template unique_lock
Class template shared_lock
Class template upgrade_lock
Class template upgrade_to_unique_lock
Mutex-specific class scoped_try_lock
lock_guard(Lockable & m)
lock_guard(Lockable & m,boost::adopt_lock_t)
~lock_guard()
#include <boost/thread/locks.hpp>

template<typename Lockable>
class lock_guard
{
public:
    explicit lock_guard(Lockable& m_);
    lock_guard(Lockable& m_,boost::adopt_lock_t);

    ~lock_guard();
};

    boost::lock_guard 非常簡單: 構造函數傳入一個可鎖定對象，構造函數取得可鎖定對象的所有權。 析構時釋放所有權。 這樣為可鎖定對像提供了一個 RAII 風格的外觀, 方便實現異常安全的鎖定和解鎖。 額外的, 構造函數the lock_guard(Lockable & m,boost::adopt_lock_t) 允許boost::lock_guard對像取得當前線程已擁有鎖定的所有權。

效果:

存儲對m的引用， 調用m.lock()。

拋出:

調用m.lock()可能拋出的異常。

前置條件:

當前線程擁有等同於函數 m.lock()調用所獲得的所有權 。

效果:

存儲對m的引用 ， 接管m 鎖定狀態。

拋出:

無

效果:

調用 m.unlock() 。

拋出:

無。

unique_lock()
unique_lock(Lockable & m)
unique_lock(Lockable & m,boost::adopt_lock_t)
unique_lock(Lockable & m,boost::defer_lock_t)
unique_lock(Lockable & m,boost::try_to_lock_t)
unique_lock(Lockable & m,boost::system_time const& abs_time)
~unique_lock()
bool owns_lock() const
Lockable* mutex() const
operator unspecified-bool-type() const
bool operator!() const
Lockable* release()
#include <boost/thread/locks.hpp>

template<typename Lockable>
class unique_lock
{
public:
    unique_lock();
    explicit unique_lock(Lockable& m_);
    unique_lock(Lockable& m_,adopt_lock_t);
    unique_lock(Lockable& m_,defer_lock_t);
    unique_lock(Lockable& m_,try_to_lock_t);
    unique_lock(Lockable& m_,system_time const& target_time);

    ~unique_lock();

    unique_lock(detail::thread_move_t<unique_lock<Lockable> > other);
    unique_lock(detail::thread_move_t<upgrade_lock<Lockable> > other);

    operator detail::thread_move_t<unique_lock<Lockable> >();
    detail::thread_move_t<unique_lock<Lockable> > move();
    unique_lock& operator=(detail::thread_move_t<unique_lock<Lockable> > other);
    unique_lock& operator=(detail::thread_move_t<upgrade_lock<Lockable> > other);

    void swap(unique_lock& other);
    void swap(detail::thread_move_t<unique_lock<Lockable> > other);

    void lock();
    bool try_lock();

    template<typename TimeDuration>
    bool timed_lock(TimeDuration const& relative_time);
    bool timed_lock(::boost::system_time const& absolute_time);

    void unlock();

    bool owns_lock() const;
    operator unspecified-bool-type() const;
    bool operator!() const;

    Lockable* mutex() const;
    Lockable* release();
};

    boost::unique_lock比 boost::lock_guard複雜許多: 不僅是它提供RAII風格的外觀, 它也允許推遲獲得鎖定, 直到lock() 函數顯式調用, 或者支持非阻塞方式獲得鎖定, 或者是支持超時鎖定。 最後, 析構函數在可鎖定對像被其鎖定的情況下調用unlock() 函數, or otherwise adopted a lock on the Lockable object。

         boost::unique_lock特化實現了 the TimedLockable concept 概念(e.g. boost::unique_lock<boost::timed_mutex>), 或者Lockable concept 概念 (e.g. boost::unique_lock<boost::mutex>)。

         如果函數mutex() 返回指向的 m指針並且owns_lock() 返回 true，該boost::unique_lock 實例擁有一個可鎖定對象的鎖定狀態 。如果該種實例被銷毀, 析構函數會調用函數mutex()->unlock()。

         boost::unique_lock的成員函數不是線程安全的。 特別的, boost::unique_lock是針對單一線程對可鎖定對像所有權建立模型的, 這樣一個對象的成員函數（包含構造析構函數）必須在同一個線程內調用。

效果:

創建一個鎖對象，沒有關聯到任何互斥量。

後置條件:

owns_lock() 返回 false，. mutex() 返回 NULL。

拋出:

無。

效果:

存儲 m的引用. 調用m.lock()。

後置條件:

owns_lock() 返回 true， mutex() 返回 &m，

拋出:

調用 m.lock()可能拋出的異常。

前置條件:

當前線程擁有對m的獨佔鎖。

效果:

存儲 m的引用 . 接管 m所有權。

後置條件:

owns_lock() 返回 true. mutex() 返回 &m。

拋出:

無

效果:

存儲 m的引用。

後置條件:

owns_lock() 返回 false. mutex() 返回 &m。

拋出:

無。

效果:

存儲 m的引用. 調用m.try_lock(), 如果調回返回 true則接管 m所有權。

後置條件:

mutex() 返回 &m。 如果對try_lock() 的調用返回 true.,那麼owns_lock() 返回 true, 否則 owns_lock() 返回 false。

拋出:

無。

效果:

存儲 m的引用. 調用 m.timed_lock(abs_time), 如果調回返回 true則接管 m所有權.

後置條件:

mutex() 返回 &m。 如果調用timed_lock() 返回true, 那麼 owns_lock() 返回 true, 否則 owns_lock() 返回 false。

拋出:

調用m.timed_lock(abs_time)可能拋出的異常 。

效果:

如果 owns_lock() 返回 true，調用 mutex()-> unlock()。

拋出:

無。

返回:

 如果該實例擁有其關聯可鎖定對象的鎖定，返回true。

拋出:

無。

返回:

返回對像關聯的可鎖定對像指針, 如果沒有返回NULL 。

拋出:

無。

返回:

如果owns_lock() 返回true, 該操作符返回邏輯上的 true , 否則為 false 。

拋出:

無。

返回:

! owns_lock()。

拋出:

無。

效果:

移除該對像和可鎖定對象的關聯, 不改變可鎖定對象的鎖定狀態。 如果在這個函數調用前owns_lock() 返回 true, it後續代碼需要保證正確解鎖可鎖定對像 。

返回:

此對像關聯的可鎖定對像指針, 如果沒有關聯，則為 NULL 。

拋出:

無。

後置條件:

該對像不再和可鎖定對像關聯。 函數mutex() 返回 NULL 並且 函數owns_lock() 返回 false。

shared_lock()
shared_lock(Lockable & m)
shared_lock(Lockable & m,boost::adopt_lock_t)
shared_lock(Lockable & m,boost::defer_lock_t)
shared_lock(Lockable & m,boost::try_to_lock_t)
shared_lock(Lockable & m,boost::system_time const& abs_time)
~shared_lock()
bool owns_lock() const
Lockable* mutex() const
operator unspecified-bool-type() const
bool operator!() const
Lockable* release()
#include <boost/thread/locks.hpp>

template<typename Lockable>
class shared_lock
{
public:
    shared_lock();
    explicit shared_lock(Lockable& m_);
    shared_lock(Lockable& m_,adopt_lock_t);
    shared_lock(Lockable& m_,defer_lock_t);
    shared_lock(Lockable& m_,try_to_lock_t);
    shared_lock(Lockable& m_,system_time const& target_time);
    shared_lock(detail::thread_move_t<shared_lock<Lockable> > other);
    shared_lock(detail::thread_move_t<unique_lock<Lockable> > other);
    shared_lock(detail::thread_move_t<upgrade_lock<Lockable> > other);

    ~shared_lock();

    operator detail::thread_move_t<shared_lock<Lockable> >();
    detail::thread_move_t<shared_lock<Lockable> > move();

    shared_lock& operator=(detail::thread_move_t<shared_lock<Lockable> > other);
    shared_lock& operator=(detail::thread_move_t<unique_lock<Lockable> > other);
    shared_lock& operator=(detail::thread_move_t<upgrade_lock<Lockable> > other);
    void swap(shared_lock& other);

    void lock();
    bool try_lock();
    bool timed_lock(boost::system_time const& target_time);
    void unlock();

    operator unspecified-bool-type() const;
    bool operator!() const;
    bool owns_lock() const;
};

         和 boost::unique_lock一樣, boost::shared_lock models對Lockable concept建模 , 但是不僅支持可鎖定對像, 還只共享鎖定獲取。

        和 boost::unique_lock一樣，不僅提供RAII風格的外觀, 它也允許推遲獲得鎖定, 直到lock() 函數顯式調用, 或者支持非阻塞方式獲得鎖定, 或者是支持超時鎖定。 最後, 析構函數在可鎖定對像被其鎖定的情況下調用unlock() 函數, or otherwise adopted a lock on the Lockable object。

         如果函數mutex() 返回指向的 m指針並且owns_lock() 返回 true，該boost::shared_lock實例擁有一個可鎖定對象的鎖定狀態 。如果該種實例被銷毀, 析構函數會調用函數mutex()->unlock()。

         boost::shared_lock的成員函數不是線程安全的。 特別的, boost::shared_lock是針對單一線程對可鎖定對像所有權建立模型的, 這樣一個對象的成員函數（包含構造析構函數）必須在同一個線程內調用。
 

效果:

創建一個不關聯到任何互斥量的鎖定對象。

後置條件:

owns_lock() 返回 false. mutex() 返回 NULL。

拋出:

無。

效果:

存儲m的引用， 並調用m.lock_shared()。。

後置條件:

owns_lock() 返回 true. mutex() 返回 &m。

拋出:

調用 m.lock_shared()可能拋出的異常。

前置條件:

當前線程擁有對 m獨佔鎖定。

效果:

存儲m的引用，接管m鎖定狀態 。

後置條件:

owns_lock() 返回 true. mutex() 返回 &m。

拋出:

無。

效果:

存儲m的引用。

後置條件:

owns_lock() 返回 false. mutex() 返回 &m。

拋出:

無。

效果:

存儲m的引用，調用m.try_lock_shared()，如果調用 返回 true則接管m鎖定狀態。

後置條件:

mutex() 返回 &m，如果調用try_lock_shared()返回 true，那麼owns_lock() 返回 true，否則 owns_lock() 返回 false。

拋出:

無。

效果:

存儲m的引用，調用m.timed_lock(abs_time)，如果調用 返回 true則接管m鎖定狀態。

後置條件:

mutex() 返回 &m. 如果調用timed_lock_shared() 返回 true，那麼owns_lock() 返回 true，否則 owns_lock() 返回 false。

拋出:

調用函數 m.timed_lock(abs_time)可能拋出的異常。

效果:

如果 owns_lock() 返回 true調用 mutex()-> unlock_shared() 。

拋出:

無。

返回:

如果對像擁有所關聯可鎖定對象的鎖定，返回true。

拋出:

無

返回:

返回對像關聯的可鎖定對像指針, 如果沒有返回NULL 。

拋出:

無。

返回:

如果owns_lock() 返回true, 該操作符返回邏輯上的 true , 否則為 false 。

拋出:

無。

返回:

! owns_lock()。

拋出:

無

效果:

移除該對像和可鎖定對象的關聯, 不改變可鎖定對象的鎖定狀態。 如果在這個函數調用前owns_lock() 返回 true, it後續代碼需要保證正確解鎖可鎖定對像 。

返回:

返回對像關聯的可鎖定對像指針, 如果沒有返回NULL 。

拋出:

無。

後置條件:

該對像不再和可鎖定對像關聯。 函數mutex() 返回 NULL 並且 函數owns_lock() 返回 false。 

#include <boost/thread/locks.hpp>

template<typename Lockable>
class upgrade_lock
{
public:
    explicit upgrade_lock(Lockable& m_);

    upgrade_lock(detail::thread_move_t<upgrade_lock<Lockable> > other);
    upgrade_lock(detail::thread_move_t<unique_lock<Lockable> > other);

    ~upgrade_lock();

    operator detail::thread_move_t<upgrade_lock<Lockable> >();
    detail::thread_move_t<upgrade_lock<Lockable> > move();

    upgrade_lock& operator=(detail::thread_move_t<upgrade_lock<Lockable> > other);
    upgrade_lock& operator=(detail::thread_move_t<unique_lock<Lockable> > other);

    void swap(upgrade_lock& other);

    void lock();
    void unlock();

    operator unspecified-bool-type() const;
    bool operator!() const;
    bool owns_lock() const;
};

          和boost::unique_lock一樣，boost::upgrade_lock對可鎖定概念建模，但是不僅限於可鎖定對提供的獨佔鎖定，還支持可升級鎖定。

         和 boost::unique_lock一樣，不僅提供RAII風格的外觀, 它也允許推遲獲得鎖定, 直到lock() 函數顯式調用, 或者支持非阻塞方式獲得鎖定, 或者是支持超時鎖定。 最後, 析構函數在可鎖定對像被其鎖定的情況下調用unlock() 函數, or otherwise adopted a lock on the Lockable object。

         如果函數mutex() 返回指向的 m指針並且owns_lock() 返回 true，該boost::upgrade_lock實例擁有一個可鎖定對象的鎖定狀態 。如果該種實例被銷毀, 析構函數會調用函數mutex()->unlock()。

         boost::upgrade_lock的成員函數不是線程安全的。 特別的, boost::upgrade_lock是針對單一線程對可鎖定對像所有權建立模型的, 這樣一個對象的成員函數（包含構造析構函數）必須在同一個線程內調用。

 

#include <boost/thread/locks.hpp>

template <class Lockable>
class upgrade_to_unique_lock
{
public:
    explicit upgrade_to_unique_lock(upgrade_lock<Lockable>& m_);

    ~upgrade_to_unique_lock();

    upgrade_to_unique_lock(detail::thread_move_t<upgrade_to_unique_lock<Lockable> > other);
    upgrade_to_unique_lock& operator=(detail::thread_move_t<upgrade_to_unique_lock<Lockable> > other);
    void swap(upgrade_to_unique_lock& other);

    operator unspecified-bool-type() const;
    bool operator!() const;
    bool owns_lock() const;
};

   boost::upgrade_to_unique_lock 允許臨時從可升級鎖定升級到獨佔鎖定，如果傳遞boost::upgrade_lock對象的引用給構造函數，該對像將升級到獨佔所有權，當這個對象銷毀時，可鎖定對像恢復為可升級鎖定。 

class MutexType::scoped_try_lock
{
private:
    MutexType::scoped_try_lock(MutexType::scoped_try_lock<MutexType>& other);
    MutexType::scoped_try_lock& operator=(MutexType::scoped_try_lock<MutexType>& other);
public:
    MutexType::scoped_try_lock();
    explicit MutexType::scoped_try_lock(MutexType& m);
    MutexType::scoped_try_lock(MutexType& m_,adopt_lock_t);
    MutexType::scoped_try_lock(MutexType& m_,defer_lock_t);
    MutexType::scoped_try_lock(MutexType& m_,try_to_lock_t);

    MutexType::scoped_try_lock(MutexType::scoped_try_lock<MutexType>&& other);
    MutexType::scoped_try_lock& operator=(MutexType::scoped_try_lock<MutexType>&& other);

    void swap(MutexType::scoped_try_lock&& other);

    void lock();
    bool try_lock();
    void unlock();
    bool owns_lock() const;

    MutexType* mutex() const;
    MutexType* release();
    bool operator!() const;

    typedef unspecified-bool-type bool_type;
    operator bool_type() const;
};

         成員類型 scoped_try_lock is 為已定義的不同的 MutexType 提供了一個類型定義。其所有的函數與boost::unique_lock<MutexType>  中的MutexType類型的相同， 除了帶參數構造函數會調用 m.try_lock()而不是調用 m.lock()。

Non-member function lock(Lockable1,Lockable2,...)
Non-member function lock(begin,end)
Non-member function try_lock(Lockable1,Lockable2,...)
Non-member function try_lock(begin,end)
template<typename Lockable1,typename Lockable2>
void lock(Lockable1& l1,Lockable2& l2);

template<typename Lockable1,typename Lockable2,typename Lockable3>
void lock(Lockable1& l1,Lockable2& l2,Lockable3& l3);

template<typename Lockable1,typename Lockable2,typename Lockable3,typename Lockable4>
void lock(Lockable1& l1,Lockable2& l2,Lockable3& l3,Lockable4& l4);

template<typename Lockable1,typename Lockable2,typename Lockable3,typename Lockable4,typename Lockable5>
void lock(Lockable1& l1,Lockable2& l2,Lockable3& l3,Lockable4& l4,Lockable5& l5);

效果:

鎖定參數提供的 Lockable 對象，並避免死鎖。 該函數在多個線程並發調用鎖定同一組互斥量（或其他可鎖定對像）是安全的，並且不用指定鎖定順序，也不用擔心死鎖。 如果函數在鎖定對像時拋出異常，那麼在函數退出前，該函數此次調用已鎖定的對象也會被釋放。

拋出:

對可鎖定對像加鎖時可能拋出的異常。

後置條件:

參數中提供的可鎖定對象都被加鎖。 

template<typename ForwardIterator>
void lock(ForwardIterator begin,ForwardIterator end);

前置條件:

ForwardIterator 的value_type需要實現 Lockable concept。

效果:

鎖定迭代區間的 Lockable 對象，並避免死鎖。 該函數在多個線程並發調用鎖定同一組互斥量（或其他可鎖定對像）是安全的，並且不用指定鎖定順序，也不用擔心死鎖。 如果函數在鎖定對像時拋出異常，那麼在函數退出前，該函數此次調用已鎖定的對象也會被釋放。

拋出:

對可鎖定對像加鎖時可能拋出的異常。 

後置條件:

迭代區間中的可鎖定對象都被加鎖。 

template<typename Lockable1,typename Lockable2>
int try_lock(Lockable1& l1,Lockable2& l2);

template<typename Lockable1,typename Lockable2,typename Lockable3>
int try_lock(Lockable1& l1,Lockable2& l2,Lockable3& l3);

template<typename Lockable1,typename Lockable2,typename Lockable3,typename Lockable4>
int try_lock(Lockable1& l1,Lockable2& l2,Lockable3& l3,Lockable4& l4);

template<typename Lockable1,typename Lockable2,typename Lockable3,typename Lockable4,typename Lockable5>
int try_lock(Lockable1& l1,Lockable2& l2,Lockable3& l3,Lockable4& l4,Lockable5& l5);

效果:

對參數中的可鎖定對像依次調用 try_lock() 函數, 如果有一個try_lock() 調用返回 false，那麼已經獲得的鎖定就會被釋放，並返回這個鎖定失敗對像在參數中的序號（以0為基數）。

如果有一個 try_lock() 調用拋出異常， 那麼已經獲得的鎖定會在函數退出前釋放。

返回:

 如果所有對象都成功加鎖，返回-1， 否則返回第一個失敗對象的序號（以0為基數）。

拋出:

調用try_lock()可能拋出的異常。

後置條件:

如果函數返回 -1, 所有對象都被加鎖，否則參數中的對象都不會加鎖。 

template<typename ForwardIterator>
ForwardIterator try_lock(ForwardIterator begin,ForwardIterator end);

前置條件:

ForwardIterator 的value_type需要實現 Lockable concept。

效果:

通過函數 try_lock()鎖定迭代區間的 Lockable 對像, 如果有一個try_lock() 調用返回 false，那麼已經獲得的鎖定就會被釋放，並返回這個鎖定失敗對像對應的迭代器。

如果有一個 try_lock() 調用拋出異常， 那麼已經獲得的鎖定會在函數退出前釋放。

返回:

如果所有對象都成功加鎖，返回end， 否則返回第一個失敗對像對應的迭代器。

拋出:

調用try_lock()可能拋出的異常。

後置條件:

如果函數返回end , 迭代區間內的對象都被加鎖，否則迭代區間內的對象都不會加鎖。

Class mutex
Typedef try_mutex
Class timed_mutex
Class recursive_mutex
Typedef recursive_try_mutex
Class recursive_timed_mutex
Class shared_mutex
Member function native_handle()
#include <boost/thread/mutex.hpp>

class mutex:
    boost::noncopyable
{
public:
    mutex();
    ~mutex();
    
    void lock();
    bool try_lock();
    void unlock();

    typedef platform-specific-type native_handle_type;
    native_handle_type native_handle();
    
    typedef unique_lock<mutex> scoped_lock;
    typedef unspecified-type scoped_try_lock;
};

    boost::mutex實現Lockable concept ， 提供一個獨佔式的互斥量。對於一個實例最多允許一個線程擁有其鎖定 。支持函數lock(), try_lock() 和 unlock() 並發調用。 

typedef platform-specific-type native_handle_type;
native_handle_type native_handle();

效果:

返回一個系統平台相關互斥類型實例（ native_handle_type ）， 可以通過系統平台函數訪問該實例。如果平台上沒有這種類型, 函數native_handle() 和native_handle_type類型也不會存在。

拋出:

無。 

#include <boost/thread/mutex.hpp>

typedef mutex try_mutex;

    boost::try_mutex 是boost::mutex的類型定義, 用於兼容以前的版本。

Member function native_handle()
#include <boost/thread/mutex.hpp>

class timed_mutex:
    boost::noncopyable
{
public:
    timed_mutex();
    ~timed_mutex();

    void lock();
    void unlock();
    bool try_lock();
    bool timed_lock(system_time const & abs_time);

    template<typename TimeDuration>
    bool timed_lock(TimeDuration const & relative_time);

    typedef platform-specific-type native_handle_type;
    native_handle_type native_handle();

    typedef unique_lock<timed_mutex> scoped_timed_lock;
    typedef unspecified-type scoped_try_lock;
    typedef scoped_timed_lock scoped_lock;
};

   boost::timed_mutex 實現TimedLockable concept ，提供一個獨佔式的互斥量。對於一個實例最多允許一個線程擁有其鎖定 。支持函數lock(), try_lock() ，timed_lock()和 unlock() 並發調用。 

typedef platform-specific-type native_handle_type;
native_handle_type native_handle();

效果:

返回一個系統平台相關互斥類型實例（ native_handle_type ）， 可以通過系統平台函數訪問該實例。如果平台上沒有這種類型, 函數native_handle() 和native_handle_type類型也不會存在。

拋出:

無。

Member function native_handle()
#include <boost/thread/recursive_mutex.hpp>

class recursive_mutex:
    boost::noncopyable
{
public:
    recursive_mutex();
    ~recursive_mutex();
    
    void lock();
    bool try_lock();
    void unlock();

    typedef platform-specific-type native_handle_type;
    native_handle_type native_handle();
    
    typedef unique_lock<recursive_mutex> scoped_lock;
    typedef unspecified-type scoped_try_lock;
};

    boost::recursive_mutex 實現了 the Lockable concept ，提供一個遞歸式的互斥量 。對於一個實例最多允許一個線程擁有其鎖定 。支持函數lock(), try_lock() 和 unlock() 並發調用。 如果一個線程已經鎖定一個boost::recursive_mutex實例， 那麼這個線程可以多次通過lock() 或 try_lock()鎖定這個實例，針對每一次成功的鎖定動作，需要調用unlock()來接觸鎖定。 

typedef platform-specific-type native_handle_type;
native_handle_type native_handle();

效果:

返回一個系統平台相關互斥類型實例（ native_handle_type ）， 可以通過系統平台函數訪問該實例。如果平台上沒有這種類型, 函數native_handle() 和native_handle_type類型也不會存在。

拋出:

無。。 

#include <boost/thread/recursive_mutex.hpp>

typedef recursive_mutex recursive_try_mutex;

    boost::recursive_try_mutex 是 boost::recursive_mutex的類型定義，, 用於兼容以前的版本。

Member function native_handle()
#include <boost/thread/recursive_mutex.hpp>

class recursive_timed_mutex:
    boost::noncopyable
{
public:
    recursive_timed_mutex();
    ~recursive_timed_mutex();
    
    void lock();
    bool try_lock();
    void unlock();

    bool timed_lock(system_time const & abs_time);

    template<typename TimeDuration>
    bool timed_lock(TimeDuration const & relative_time);

    typedef platform-specific-type native_handle_type;
    native_handle_type native_handle();
    
    typedef unique_lock<recursive_timed_mutex> scoped_lock;
    typedef unspecified-type scoped_try_lock;
    typedef scoped_lock scoped_timed_lock;
};

    boost::recursive_timed_mutex 實現TimedLockable concept ，提供一個遞歸式的互斥量。對於一個實例最多允許一個線程擁有其鎖定 。支持函數lock(), try_lock() ，timed_lock()和 unlock() 並發調用。如果一個線程已經鎖定一個boost::recursive_timed_mutex實例， 那麼這個線程可以多次通過lock() ，timed_lock()或 try_lock()鎖定這個實例，針對每一次成功的鎖定動作，需要調用unlock()來接觸鎖定。 

typedef platform-specific-type native_handle_type;
native_handle_type native_handle();

效果:

返回一個系統平台相關互斥類型實例（ native_handle_type ）， 可以通過系統平台函數訪問該實例。如果平台上沒有這種類型, 函數native_handle() 和native_handle_type類型也不會存在。

拋出:

無。. 

#include <boost/thread/shared_mutex.hpp>

class shared_mutex
{
public:
    shared_mutex();
    ~shared_mutex();

    void lock_shared();
    bool try_lock_shared();
    bool timed_lock_shared(system_time const& timeout);
    void unlock_shared();

    void lock();
    bool try_lock();
    bool timed_lock(system_time const& timeout);
    void unlock();

    void lock_upgrade();
    void unlock_upgrade();

    void unlock_upgrade_and_lock();
    void unlock_and_lock_upgrade();
    void unlock_and_lock_shared();
    void unlock_upgrade_and_lock_shared();
};

         boost::shared_mutex 提供了一個multiple-reader / single-writer互斥量，實現了UpgradeLockable concept.。

         允許並發調用函數 lock(), try_lock(), timed_lock(), lock_shared(), try_lock_shared() 和 timed_lock_shared()。 

Class condition_variable
Class condition_variable_any
Typedef condition
 概述

        類型 condition_variable 和 condition_variable_any 提供一個種機制，一個線程可以等待另外一個線程內某個事件發生的通知。 通常的應用模式是一個線程鎖定一個互斥量，然後通過函數wait等待一個condition_variable 或 condition_variable_any實例，當線程從wait 函數激活時 ， 檢查特定的條件是否滿足，如果滿足，線程繼續執行；如果不滿足，線程繼續等待。最簡單的情況下，這個條件只是一個布爾變量。 

boost::condition_variable cond;
boost::mutex mut;
bool data_ready;

void process_data();

void wait_for_data_to_process()
{
    boost::unique_lock<boost::mutex> lock(mut);
    while(!data_ready)
    {
        cond.wait(lock);
    }
    process_data();
}

         請注意 lock 對像會傳遞給 wait函數: wait 函數會自動將線程添加到等待條件變量的線程集合中，並且解鎖傳遞進來的互斥量。 當線程被喚醒，函數退出前互斥量會再次被鎖定。這樣允許其他線程獲取互斥量來更新共享的數據，確保條件變量關聯的數據被正確同步。

        同時，另外的線程將這個條件置為true，and 然後對條件變量調用函數 notify_one 或 notify_all來喚醒等待該條件變量的一個線程或多個線程 。 

void retrieve_data();
void prepare_data();

void prepare_data_for_processing()
{
    retrieve_data();
    prepare_data();
    {
        boost::lock_guard<boost::mutex> lock(mut);
        data_ready=true;
    }
    cond.notify_one();
}

         注意，同一個互斥量在共享數據被更新前被鎖定，但是這個互斥量鎖定範圍不需要包含函數notify_one.調用。

         這個例子使用一個condition_variable對像，如果換成condition_variable_any對象也是同樣適用。

         condition_variable_any 更加通用，支持和其他類型的互斥量和鎖定類型，而condition_variable 要求傳遞給函數wait的是 boost::unique_lock<boost::mutex>對象。這樣在已知互斥量的條件下， condition_variable 可以做適當的優化； condition_variable_any 類型的實現比 condition_variable複雜許多。

condition_variable()
~condition_variable()
void notify_one()
void notify_all()
void wait(boost::unique_lock<boost::mutex>& lock)
template<typename predicate_type> void wait(boost::unique_lock<boost::mutex>& lock, predicate_type pred)
bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time const& abs_time)
template<typename duration_type> bool timed_wait(boost::unique_lock<boost::mutex>& lock,duration_type const& rel_time)
template<typename predicate_type> bool timed_wait(boost::unique_lock<boost::mutex>& lock, boost::system_time const& abs_time, predicate_type pred)
#include <boost/thread/condition_variable.hpp>

namespace boost
{
    class condition_variable
    {
    public:
        condition_variable();
        ~condition_variable();

        void notify_one();
        void notify_all();

        void wait(boost::unique_lock<boost::mutex>& lock);

        template<typename predicate_type>
        void wait(boost::unique_lock<boost::mutex>& lock,predicate_type predicate);

        bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time const& abs_time);

        template<typename duration_type>
        bool timed_wait(boost::unique_lock<boost::mutex>& lock,duration_type const& rel_time);

        template<typename predicate_type>
        bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time const& abs_time,predicate_type predicate);

        template<typename duration_type,typename predicate_type>
        bool timed_wait(boost::unique_lock<boost::mutex>& lock,duration_type const& rel_time,predicate_type predicate);

    // backwards compatibility

        bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::xtime const& abs_time);

        template<typename predicate_type>
        bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::xtime const& abs_time,predicate_type predicate);
    };
}

效果:

創建一個條件變量對象。

拋出:

如果出現錯誤，拋出異常boost::thread_resource_error。

前置條件:

所有等待這個條件變量的線程得到通知（通過調用函數notify_one 或notify_all， 儘管不是每個獨立的函數調用wait或 timed_wait  都返回)。

效果:

銷毀條件變量。

拋出:

無。

效果:

如果有線程當前因為等待這個條件變量（wait 或timed_wait）阻塞，這個函數調用會解除一個線程的阻塞狀態。

拋出:

無。

效果:

如果有線程當前因為等待這個條件變量（wait 或timed_wait）阻塞，這個函數調用會解除所有這些線程的阻塞狀態。

拋出:

無。

前置條件:

lock對像被當前線程鎖定, 或者被等待該狀態變量的其他線程鎖定,或者所有在等待該狀態變量的線程傳遞的lock對像指向相同的互斥量。

效果:

自動調用 lock.unlock()並且阻塞當前線程。 線程在函數notify_one()或notify_all調用通知後解除阻塞狀態，然後線程在 wait函數退出前調用lock.lock() 來加鎖。如果這個函數因為異常退出，退出前也會調用lock.lock()。

後置條件:

當前線程鎖定lock。

拋出:

如果出錯拋出異常boost::thread_resource_error。如果對線程執行體關聯的boost::thread對像調用函數interrupt()， 拋出boost::thread_interrupted異常。

效果:

As-if 

while(!pred())
{
    wait(lock);
}

前置條件:

lock對像被當前線程鎖定, 或者被等待該狀態變量的其他線程鎖定,或者所有在等待該狀態變量的線程傳遞的lock對像指向相同的互斥量。

效果:

自動調用 lock.unlock()並且阻塞當前線程。 線程在函數notify_one()或notify_all調用通知後解除阻塞狀態，另外在boost::get_system_time()得到的時間超過abs_time後線程也會解除阻塞， 然後線程在 wait函數退出前調用lock.lock() 來加鎖。如果這個函數因為異常退出，退出前也會調用lock.lock()。

返回:

如果函數因為指定的時間到達而退出，返回false，否則 true。

後置條件:

當前線程鎖定lock。

拋出:

如果出錯拋出異常boost::thread_resource_error。如果對線程執行體關聯的boost::thread對像調用函數interrupt()， 拋出boost::thread_interrupted異常。

前置條件:

lock對像被當前線程鎖定, 或者被等待該狀態變量的其他線程鎖定,或者所有在等待該狀態變量的線程傳遞的lock對像指向相同的互斥量。

效果:

自動調用 lock.unlock()並且阻塞當前線程。 線程在函數notify_one()或notify_all調用通知後解除阻塞狀態，另外在等待時間段超過rel_time 後線程也會解除阻塞， 然後線程在 wait函數退出前調用lock.lock() 來加鎖。如果這個函數因為異常退出，退出前也會調用lock.lock()。 

返回:

如果函數因為指定的時間段到達而退出，返回false，否則 true。

後置條件:

當前線程鎖定lock。

拋出:

如果出錯拋出異常boost::thread_resource_error。如果對線程執行體關聯的boost::thread對像調用函數interrupt()， 拋出boost::thread_interrupted異常。

[Note] 注意：

使用時間段參數的函數難以正確使用， 通常情況下帶斷言的重載比較容易使用。

效果:

As-if 

while(!pred())
{
    if(!timed_wait(lock,abs_time))
    {
        return pred();
    }
}
return true;

condition_variable_any()
~condition_variable_any()
void notify_one()
void notify_all()
template<typename lock_type> void wait(lock_type& lock)
template<typename lock_type,typename predicate_type> void wait(lock_type& lock, predicate_type pred)
template<typename lock_type> bool timed_wait(lock_type& lock,boost::system_time const& abs_time)
template<typename lock_type,typename duration_type> bool timed_wait(lock_type& lock,duration_type const& rel_time)
template<typename lock_type,typename predicate_type> bool timed_wait(lock_type& lock, boost::system_time const& abs_time, predicate_type pred)
#include <boost/thread/condition_variable.hpp>

namespace boost
{
    class condition_variable_any
    {
    public:
        condition_variable_any();
        ~condition_variable_any();

        void notify_one();
        void notify_all();

        template<typename lock_type>
        void wait(lock_type& lock);

        template<typename lock_type,typename predicate_type>
        void wait(lock_type& lock,predicate_type predicate);

        template<typename lock_type>
        bool timed_wait(lock_type& lock,boost::system_time const& abs_time);

        template<typename lock_type,typename duration_type>
        bool timed_wait(lock_type& lock,duration_type const& rel_time);

        template<typename lock_type,typename predicate_type>
        bool timed_wait(lock_type& lock,boost::system_time const& abs_time,predicate_type predicate);

        template<typename lock_type,typename duration_type,typename predicate_type>
        bool timed_wait(lock_type& lock,duration_type const& rel_time,predicate_type predicate);

    // backwards compatibility

        template<typename lock_type>
        bool timed_wait(lock_type>& lock,boost::xtime const& abs_time);

        template<typename lock_type,typename predicate_type>
        bool timed_wait(lock_type& lock,boost::xtime const& abs_time,predicate_type predicate);
    };
}

效果:

創建一個condition_variable_any對象。

拋出:

如果出錯拋出boost::thread_resource_error 異常。

前置條件:

所有等待這個條件變量的線程得到通知（通過調用函數notify_one 或notify_all， 儘管不是每個獨立的函數調用wait或 timed_wait  都返回)。

效果:

銷毀這個對象。

拋出:

無。

效果:

如果有線程當前因為等待這個條件變量（wait 或timed_wait）阻塞，這個函數調用會解除一個線程的阻塞狀態。

拋出:

無。

效果:

如果有線程當前因為等待這個條件變量（wait 或timed_wait）阻塞，這個函數調用會解除所有這些線程的阻塞狀態。

拋出:

無。

效果:

自動調用 lock.unlock()並且阻塞當前線程。 線程在函數notify_one()或notify_all調用通知後解除阻塞狀態，然後線程在 wait函數退出前調用lock.lock() 來加鎖。如果這個函數因為異常退出，退出前也會調用lock.lock()。

後置條件:

當前線程鎖定lock。

拋出:

如果出錯拋出異常boost::thread_resource_error。如果對線程執行體關聯的boost::thread對像調用函數interrupt()， 拋出boost::thread_interrupted異常。

效果:

As-if 

while(!pred())
{
    wait(lock);
}

效果:

自動調用 lock.unlock()並且阻塞當前線程。 線程在函數notify_one()或notify_all調用通知後解除阻塞狀態，另外在boost::get_system_time()得到的時間超過abs_time後線程也會解除阻塞， 然後線程在 wait函數退出前調用lock.lock() 來加鎖。如果這個函數因為異常退出，退出前也會調用lock.lock()。

返回:

如果函數因為指定的時間到達而退出，返回false，否則 true。

後置條件:

當前線程鎖定lock。

拋出:

如果出錯拋出異常boost::thread_resource_error。如果對線程執行體關聯的boost::thread對像調用函數interrupt()， 拋出boost::thread_interrupted異常。

效果:

自動調用 lock.unlock()並且阻塞當前線程。 線程在函數notify_one()或notify_all調用通知後解除阻塞狀態，另外在等待時間段超過rel_time 後線程也會解除阻塞， 然後線程在 wait函數退出前調用lock.lock() 來加鎖。如果這個函數因為異常退出，退出前也會調用lock.lock()。 

返回:

如果函數因為指定的時間段到達而退出，返回false，否則 true。

後置條件:

當前線程鎖定lock。

拋出:

如果出錯拋出異常boost::thread_resource_error。如果對線程執行體關聯的boost::thread對像調用函數interrupt()， 拋出boost::thread_interrupted異常。

[Note] 注意：

使用時間段參數的函數難以正確使用， 通常情況下帶斷言的重載比較容易使用。

效果:

As-if 

while(!pred())
{
    if(!timed_wait(lock,abs_time))
    {
        return pred();
    }
}
return true;


#include <boost/thread/condition.hpp>

typedef condition_variable_any condition;

      condition 類型提供對以前版本的兼容。

Typedef once_flag
Non-member function call_once

   boost::call_once 提供一個機制，確保初始化函數只執行一次，並避免數據競態或死鎖。 

#include <boost/thread/once.hpp>

typedef platform-specific-type once_flag;
#define BOOST_ONCE_INIT platform-specific-initializer

      boost::once_flag對像由BOOST_ONCE_INIT初始化: 

boost::once_flag f=BOOST_ONCE_INIT;

#include <boost/thread/once.hpp>

template<typename Callable>
void call_once(once_flag& flag,Callable func);

Requires:

Callable 類型要求 CopyConstructible。拷貝func 不能有副效果（side effect），並且拷貝和原始對像有相同的調用效果。

效果:

對同一個 once_flag 對像調用call_once 被序列化了。如果在此之前沒有有效的call_once調用，func()對像會被調用，如果func()成功，那麼call_once 調用被視為有效的，如果func() t拋出異常，該異常被傳遞到調用者，call_once調用被視為無效的；如果對同一個once_flag 對像有過有效的call_once 調用，call_once只是簡單返回，並不調用func。

同步:

對once_flag對像有效調用call_once後，後續對該once_flag 的call_once調用會被同步。

拋出:

如果初始化效果不能達到，拋出thread_resource_error，或者func 拋出的異常。 

void call_once(void (*func)(),once_flag& flag);

       第二個重載提供向前的兼容支持。

       函數call_once(func,flag)的效果和call_once(flag,func)一樣。

Class barrier

      是一個簡單的概念，也被稱為 rendezvous, 是多個線程間的同步點。barrier被配置為一定數量的線程使用(n)，當線程到達barrier時，他們必須等待，直到所有線程都到達這個barrier。當最後一個線程到達這個barrier，所有的線程才能繼續執行，並且這個barrier對像被復位。 

#include <boost/thread/barrier.hpp>

class barrier
{
public:
    barrier(unsigned int count);
    ~barrier();

    bool wait();
};

     boost::barrier 對像不支持拷貝和轉移。

Constructor 
barrier(unsigned int count);

效果:

構造一個支持 count 個線程的barrier 線程。

拋出:

如果出錯，拋出boost::thread_resource_error 異常。

Destructor 
~barrier();

前置條件:

沒有線程在等待這個對象。

效果:

銷毀這個對象。

拋出:

無。

Member function wait 
bool wait();

效果:

阻塞當前線程直到 count 個線程對這個對象調用wait,當第count個線程調用 wait，所有阻塞的線程解除阻塞，barrier對像被復位。

返回:

true for exactly one thread from each batch of waiting threads, false otherwise。

拋出:

如果出錯，拋出boost::thread_resource_error 異常。

Copyright 頲007 -8 Anthony Williams

Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

PrevUpHomeNext