boost多线程之mutex与lock-ag真人游戏

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可以mutex中的任意一种。
如果t为mutex，那么boost::unique_lock，构造与析构时则分别自动调用lock和unlock方法。
如果t为shared_mutex，那么boost::unique_lock，构造与析构时则分别调用shared_mutex的shared_lock和shared_unlock方法。
注意：scoped_lock也是独占锁，其源代码中定义如下；
typedef unique_lock scoped_lock;
typedef unique_lock scoped_timed_lock;

▲ 共享锁：
boost::shared_lock，其中的t只能是shared_mutex类。

3. 读写锁的实现

typedef boost::shared_lock readlock;
typedef boost::unique_lock 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 lk(m);
  process(data);
};
// lock_guard只能像上面这样使用，而unique_lock允许设置超时，推迟锁定lock以及在对象销毁之前unlock。
{
  boost::unique_lock lk( m );
  process( data );
  lk.unlock( );
  // do other thing
};
// 设置锁超时
{
  boost::unique_lock 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 lock(mutex);
            print_debug(i);
        }
    }
    void threadfun3()
    {
        for (int i = 0; i < 5;   i)
        {
            wait(1);
            // unique_lock = scoped_lock
            boost::unique_lock 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();
}