【Boost】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. 读写锁的实现

[cpp] view
plain copy

 print?

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<>的区别

[cpp] view
plain copy

 print?

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. 简单示例

[cpp] view
plain copy

 print?

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();  

}