- Mutex对象
#include <boost/thread/mutex.hpp>
#include <boost/thread/shared_mutex.hpp>
boost::mutex //支持排他访问的互斥对象。
boost::try_mutex //等同于 boost::mutex, 用来兼容以前的版本。
boost::timed_mutex //支持超时的排他互斥对象。
boost::recursive_mutex //支持递归加锁的排他互斥对象。
boost::recursive_timed_mutex //支持递归和超时的排他互斥对象。
boost::shared_mutex //可共享的互斥对象。
- Lock对象
#include <boost/thread/locks.hpp>
boost::lock_guard //是最简单的锁,构造时对传入的mutex加锁,析构时解锁。
boost::unique_lock /*可以推迟lock(构造时指定defer_lock_t参数), 通过调用加锁函数显示lock:ock(), try_lock(),time_lock(),可以调用unlock()解锁,或unique_lock对象析构时自动解锁。*/
boost::shared_lock //类似于unique_lock,不同的是获得的是共享访问权限(前面获得的都是排他权限)。
boost::upgrade_lock //获得可升级的访问权限。
boost::upgrade_to_unique_lock //提升upgrade_lock权限,析构时upgrade_lock权限降级。
explicit upgrade_to_unique_lock(upgrade_lock<Lockable>& m_);
- Lock函数(全局函数)
lock(Lockable1,Lockable2,...)
lock(begin,end) // 将lockable对象(mutex)放到一个容器中
try_lock(Lockable1,Lockable2,...)
try_lock(begin,end)
用来对多个顺序不确定的mutex同时加锁,以避免死锁。
- 条件变量 condition_variable
提供机制实现一个线程为某个条件等待来自另一个线程的通知。
Notice that the lock is passed to wait():wait will atomically add the thread to the set of threads waiting on the condition variable, and unlock the mutex.
boost::condition_variable
boost::condition_variable_any
通常的用法示例如下:
互斥锁 mutex
支持排他访问的互斥对象,当多个线程对同一临界资源进行访问时候,只有获得锁的线程可以获得临界资源,其他等待资源的线程都会被阻塞。例如一个卫生间里面只有一个坑,有是个人抢着去蹬坑,每次一个人进去后,其他人就不能进去。
示例
#include "stdafx.h"
#include <iostream>
#include <boost/signal.hpp>
#include <boost/bind.hpp>
#include <boost/thread.hpp>
using namespace std;
//互斥锁的使用
boost::mutex g_mutex;
void wait(int second)
{
boost::this_thread::sleep(boost::posix_time::microsec(second));
}
void ThreadFun()
{
boost::lock_guard<boost::mutex> lock(g_mutex);
cout << boost::this_thread::get_id() << ":开始蹬坑" << endl;
wait(500);
cout << boost::this_thread::get_id() << ":结束蹬坑\n\n" << endl;
}
int main()
{
//10个人在厕所外面排队等着蹬坑
for (int i = 0; i < 10; i++)
{
boost::thread t(ThreadFun);
}
getchar();
return 0;
}
不加锁的情况下其输出结果
31804b8c:开始蹬坑
3c28:开始蹬坑
2308:开始蹬坑
4c08:开始蹬坑
3578:开始蹬坑
17460:开始蹬坑
3c64:开始蹬坑
2118:开始蹬坑
:开始蹬坑
3f04:开始蹬坑
3f04:结束蹬坑
17460:结束蹬坑
3c64:结束蹬坑
2118:结束蹬坑
3180:结束蹬坑
15400:结束蹬坑
4c08:结束蹬坑
4b8c:结束蹬坑
3578:结束蹬坑
2308:结束蹬坑
加锁情况下
26b0:开始蹬坑
26b0:结束蹬坑
4378:开始蹬坑
4378:结束蹬坑
3c40:开始蹬坑
3c40:结束蹬坑
e10:开始蹬坑
e10:结束蹬坑
3960:开始蹬坑
3960:结束蹬坑
1420:开始蹬坑
1420:结束蹬坑
41e4:开始蹬坑
41e4:结束蹬坑
476c:开始蹬坑
476c:结束蹬坑
1184:开始蹬坑
1184:结束蹬坑
282c:开始蹬坑
282c:结束蹬坑
不加锁的情况下所有人一股脑冲进测试,至于怎么解决问题的不想而知,而加锁的情况下,只有等一个人用完厕所之后,其余人才能进去。
读写锁 shared_mutex
shared_mutex即读写锁,不同与我们常用的独占式锁mutex,shared_mutex是共享与独占共存的锁,实现了读写锁的机制,即多个读线程一个写线程,通常用于对于一个共享区域的读操作比较频繁,而写操作比较少的情况。
读写锁比起mutex具有更高的适用性,具有更高的并行性,可以有多个线程同时占用读模式的读写锁,但是只能有一个线程占用写模式的读写锁,读写锁的基本规则可以总结为“写优先,读共享,交叉互斥“,具体表现为读写锁的三种状态:
(1)当读写锁是写加锁状态时,在这个锁被解锁之前,所有试图对这个锁加锁的线程都会被阻塞。(交叉互斥)
(2)当读写锁在读加锁状态时,所有试图以读模式对它进行加锁的线程都可以得到访问权,但是以写模式对它进行加锁的线程将会被阻塞。(读共享,交叉互斥)
(3)当读写锁在读模式的锁状态时,如果有另外的线程试图以写模式加锁,读写锁通常会阻塞随后的读模式锁的请求,这样可以避免读模式锁长期占用,而等待的写模式锁请求则长期阻塞。(写优先)
注:其实在读者-写者问题中,有读者优先和写者优先两种模式,只是在boost中的shared_mutex默认的实现是写者优先,这其实也是有道理的,因为在我们总是希望读到的数据是最新的,这就得保证写者优先。
下面通过一个 boost::shared_mutex的应用实例来反应其锁机制,该例子中我们建立两个读者线程,两个写者线程,程序的实际运行结果很直接的反应了shared_mutex应用情况。
#include <boost\ref.hpp>
#include <boost\thread\thread.hpp>
#include <string>
using namespace boost;
int g_num = 10; //全局变量,写者改变该全局变量,读者读该全局变量
shared_mutex s_mu; //全局shared_mutex对象
//写线程
void read_(std::string &str)
{
const char* c = str.c_str();
while (1)
{
{
shared_lock<shared_mutex> m(s_mu); //读锁定,shared_lock
printf("线程%s进入临界区,global_num = %d\n", c, g_num);
boost::this_thread::sleep(boost::posix_time::seconds(1)); //sleep 1秒,给足够的时间看其他线程是否能进入临界区
printf("线程%s离开临界区...\n", c);
}
boost::this_thread::sleep(boost::posix_time::seconds(1)); //读线程离开后再slpp 1秒(改变这个值可以看到不一样的效果)
}
}
//读线程
void writer_(std::string &str)
{
const char* c = str.c_str();
while (1)
{
{
unique_lock<shared_mutex> m(s_mu); //写锁定,unique_lock
++g_num;
printf("线程%s进入临界区,global_num = %d\n", c, g_num);
boost::this_thread::sleep(boost::posix_time::seconds(1)); //sleep 1秒,让其他线程有时间进入临界区
printf("线程%s离开临界区...\n", c);
}
boost::this_thread::sleep(boost::posix_time::seconds(2)); //写线程离开后再slpp 2秒,这里比读线程多一秒是因为如果这里也是1秒,那两个写线程一起请求锁时会让读线程饥饿
}
}
int main()
{
std::string r1 = "read_1";
std::string r2 = "read_2";
std::string w1 = "writer_1";
std::string w2 = "writer_2";
boost::thread_group tg;
tg.create_thread(bind(read_, boost::ref(r1))); //两个读者
tg.create_thread(bind(read_, boost::ref(r2)));
tg.create_thread(bind(writer_, boost::ref(w1))); //两个写者
tg.create_thread(bind(writer_, boost::ref(w2)));
tg.join_all();
return 0;
}
定时锁 timer_mutex
同样是上厕所,现在每个人规定了,只能使用三分钟的厕所,如果超过这个时间,那么我就踹门进去,把你给拉出来,强制你出来。
示例:
#include "stdafx.h"
#include <iostream>
#include <boost/signal.hpp>
#include <boost/bind.hpp>
#include <boost/thread.hpp>
using namespace std;
//互斥锁的使用
boost::timed_mutex g_mutex;
void wait(int second)
{
boost::this_thread::sleep(boost::posix_time::seconds(second));
}
void ThreadFun()
{
boost::unique_lock<boost::timed_mutex> lock(g_mutex,boost::try_to_lock);
while (!lock.owns_lock())
{
lock.timed_lock(boost::get_system_time() + boost::posix_time::seconds(3));
}
cout << boost::this_thread::get_id() << ":开始蹬坑" << endl;
wait(2);
cout << boost::this_thread::get_id() << ":结束蹬坑\n\n" << endl;
}
int main()
{
//10个人在厕所外面排队等着蹬坑
for (int i = 0; i < 10; i++)
{
boost::thread t(ThreadFun);
}
getchar();
return 0;
}