本文共 2792 字，大约阅读时间需要 9 分钟。
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方法。▲ 独占锁：
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等。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的线程。
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 );
};
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();
}
转载地址：http://culoi.baihongyu.com/