boost鎖的簡單用法

boost庫中提供了mutex類與lock類，通過組合可以輕易的構建讀寫鎖與互斥鎖。

mutex對象類

mutex類主要有兩種：boost::mutex，boost::shared_mutex，其中mutex有lock和unlock方法，shared_mutex除了提供lock和unlock方法外，還有shared_lock和shared_unlock方法。因此，boost::mutex爲獨佔互斥類，boost::shared_mutex爲共享互斥類。

lock模板類

boost::unique_lock<T>，boost::shared_lock<T>，其中unique_lock爲獨佔鎖，shared_lock爲共享鎖。unique_lock<T>中的T可以爲mutex類中的任意一種，如果爲shared_mutex，那麼boost:: unique_lock<boost::shared_mutex>類的對象構造函數構造時，會自動調用shared_mutex的shared_lock方法，析構函數裏，會自動調用shared_mutex的shared_unlock方法。如果是boost:: unique_lock<boost::mutex>，則分別自動調用lock和unlock方法。

boost::shared_lock<T>中的T只能是shared_mutex類。

讀寫鎖的實現

typedef boost::shared_lock<boost::shared_mutex> readLock;
typedef boost:: unique_lock<boost::shared_mutex> writeLock;

boost::shared_mutex rwmutex;

void readOnly()
{
    readLock rdlock( rwmutex );
    /// do something
}


void writeOnly()
{
    writeLock wtlock( rwmutex );
    /// do something
}

注意：此處沒有顯示的解鎖，這是因爲，當函數執行完畢之後，就會析構對象，析構的同時，會自動調用shared_unlock方法。
對同一個rwmutex，線程可以同時有多個readLock，這些readLock會阻塞任意一個企圖獲得writeLock的線程，直到所有的readLock對象都析構。如果writeLock首先獲得了rwmutex，那麼它會阻塞任意一個企圖在rwmutex上獲得readLock或者writeLock的線程。


互斥鎖的實現

typedef boost:: unique_lock<boost::mutex> exclusiveLock;

遞歸式的互斥量

boost::recursive_mutex提供一個遞歸式的互斥量。對於一個實例最多允許一個線程擁有其鎖定，如果一個線程已經鎖定一個boost::recursive_mutex實例，那麼這個線程可以多次鎖定這個實例。

boost::mutex::scoped_lock
boost::mutex io_mutex;

void foo()
{
{
    boost::mutex::scoped_lock lock( io_mutex ); /// 鎖定
} /// 解鎖
}

其它

boost::mutex

boost::timed_mutex

boost::shared_mutex

boost::recursive_mutex

boost::recursive_timed_mutex


boost::lock_guard

boost::shared_lock

boost::upgrade_lock

boost::unique_lock

boost::upgrade_to_unique_lock

/////////////////////////////////////////////////////////////////////////////////////////////////

 QuickFix中提供了Mutex類、Locker類

/// Portable implementation of a mutex.

class Mutex
{
    Mutex( );
    ~Mutex( );
    void lock( );
    void unlock( );
};

/// Locks/Unlocks a mutex using RAII.

class Locker
{
    Locker( Mutex& mutex );
    ~Locker( );
};

/// Does the opposite of the Locker to ensure mutex ends up in a locked state.

class ReverseLocker
{
    ReverseLocker( Mutex& mutex );
    ~ReverseLocker( );
}

boost::lock_guard<>和boost::unique_lock<>的區別

boost::mutex m;

void foo( )
{
    boost::lock_guard<boost::mutex> lk( m );
    process( data );
};

lock_guard只能像上面這樣使用，而unique_lock允許設置超時，推遲鎖定lock以及在對象銷燬之前unlock。
{
boost::unique_lock<boost::mutex> lk( m );
process( data );
lk.unlock( );
// do other thing
};


設置鎖超時

boost::unique_lock<boost::timed_mutex> lk( m, std::chrono::milliseconds(3) ); // 超時3秒

if( lk ) process( data );

upgrade_lock類

什麼是upgrade_lock，它的最大特點就是與shared_lock不互斥，與別的upgrade_lock和unique_lock互斥。也就是說線程A獲得mutex的upgrade_lock後，線程B、C等還可以獲得mutex的share_mutex，反之亦然。

不僅限於可鎖定對提供的獨佔鎖定，還支持可升級鎖定。