boost庫中thread多線程詳解2——mutex與lock

1. mutex對象類

mutex類主要有兩種：獨占式與共享式的互斥量。
▲ 獨占式互斥量：
mutex: 獨占式的互斥量，是最簡單最常用的一種互斥量類型
try_mutex: 它是mutex的同義詞，為了與兼容以前的版本而提供
timed_mutex: 它也是獨占式的互斥量，但提供超時鎖定功能
▲ 遞歸式互斥量：
recursive_mutex: 遞歸式互斥量，可以多次鎖定，相應地也要多次解鎖
recursive_try_mutex: 它是recursive_mutex 的同義詞，為了與兼容以前的版本而提供
recursive_timed_mutex: 它也是遞歸式互斥量，基本功能同recursive_mutex, 但提供超時鎖定功能
▲ 共享式互斥量：
shared_mutex: multiple-reader/single-writer 型的共享互斥量(又稱讀寫鎖)。
其中mutex有lock和unlock方法，shared_mutex除了提供lock和unlock方法外，還有shared_lock和shared_unlock方法。

2. lock模板類

▲ 獨占鎖：
boost::unique_lock<T>，其中T可以mutex中的任意一種。
  如果T為mutex，那么boost::unique_lock<boost::mutex>，構造與析構時則分別自動調用lock和unlock方法。
  如果T為shared_mutex，那么boost::unique_lock<boost::shared_mutex>，構造與析構時則分別調用shared_mutex的shared_lock和shared_unlock方法。
注意：scoped_lock也是獨占鎖，其源代碼中定義如下；
  typedef unique_lock<mutex> scoped_lock;
  typedef unique_lock<timed_mutex> scoped_timed_lock;
▲ 共享鎖：
boost::shared_lock<T>，其中的T只能是shared_mutex類。
當然還有其他一些鎖：lock_guard, upgrade_lock等。

3. 讀寫鎖的實現

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
}

對同一個rwmutex，線程可以同時有多個readLock，這些readLock會阻塞任意一個企圖獲得writeLock的線程，直到所有的readLock對象都析構。如果writeLock首先獲得了rwmutex，那么它會阻塞任意一個企圖在rwmutex上獲得readLock或者writeLock的線程。

4. 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 );
};

 

5. 簡單示例

namespace
{
    boost::mutex mutex;
    boost::shared_mutex shared_mutex;

    void wait(int seconds)
    {
        boost::this_thread::sleep(boost::posix_time::seconds(seconds));
    }

    void threadfun1()
    {
        for (int i = 0; i < 5; ++i)
        {
            wait(1);
            mutex.lock();
            PRINT_DEBUG(i);
            mutex.unlock();
        }
    }

    void threadfun2()
    {
        for (int i = 0; i < 5; ++i)
        {
            wait(1);
            boost::lock_guard<boost::mutex> lock(mutex);
            PRINT_DEBUG(i);
        }
    }

    void threadfun3()
    {
        for (int i = 0; i < 5; ++i)
        {
            wait(1);
            // unique_lock<boost::mutex> = scoped_lock
            boost::unique_lock<boost::mutex> lock(mutex);
            std::cout << lock.owns_lock() << std::endl;
            PRINT_DEBUG(i);
        }
    }
}

// 1. mutex例子
void test_thread_syn1()
{
    boost::thread t1(&threadfun1);
    boost::thread t2(&threadfun1);

    t1.join();
    t2.join();
}

//  2. lock_guard例子
void test_thread_syn2()
{
    boost::thread t1(&threadfun2);
    boost::thread t2(&threadfun2);

    t1.join();
    t2.join();
}

// 3. scoped_lock例子
void test_thread_syn3()
{
    boost::thread t1(&threadfun3);
    boost::thread t2(&threadfun3);

    t1.join();
    t2.join();
}