C++11中std::lock_guard和std::unique_lock的使用
1. 原理
在互斥类最重要的成员函数是lock()和unlock。通常在进入临界区时，需要进行加锁操作，在退出临界区时，进行解锁操作。更好的办法是采用资源分配时初始化(RAII)方法来加锁、解锁，这避免了在临界区中因为抛出异常或return等操作导致没有解锁就退出的问题。
std::lock_guard类模板做mutex的RAII， 避免因为return或者异常导致的解锁失败而导致资源泄漏。
std::lock_guard类的构造函数禁用拷贝构造，且禁用移动构造。std::lock_guard类除了构造函数和析构函数外没有其它成员函数。
在std::lock_guard对象构造时，传入的mutex对象(即它所管理的mutex对象)会被当前线程锁住。在lock_guard对象被析构时，它所管理的mutex对象会自动解锁，不需要程序员手动调用lock和unlock对mutex进行上锁和解锁操作。lock_guard对象并不负责管理mutex对象的生命周期，lock_guard对象只是简化了mutex对象的上锁和解锁操作，方便线程对互斥量上锁，即在某个lock_guard对象的生命周期内，它所管理的锁对象会一直保持上锁状态；而lock_guard的生命周期结束之后，它所管理的锁对象会被解锁。程序员可以非常方便地使用lock_guard，而不用担心异常安全问题。
std::lock_guard在构造时只被锁定一次，并且在销毁时解锁。
2. std::lock_guard用例
#include
#include
class CLockGuard {
public:
void add_to_list(int new_value) {
std::lock_guard guard;
m_list.push_back(new_value);
}
bool list_contains(int value_to_find) {
std::lock_guard guard(m_mutex);
return std::find(m_list.begin(), m_list.end(), value_to_find) != m.list.end();
}
private:
std::list m_list; //共享数据
std::mutex m_mutex; // 互斥量
}
两个要点：
1、互斥量和被保护的数据，需要定义为private成员；
2、在成员函数中加入一个std::lock_guard对象；
上述实现可使得两个成员函数对被保护数据的访问是互斥的。
- 1.std::lock_guard 在构造函数中进行加锁，析构函数中进行解锁。
- 2.锁在多线程编程中，使用较多，因此c++11提供了lock_guard模板类；在实际编程中，我们也可以根据自己的场景编写resource_guard RAII类，避免忘掉释放资源。
#include
#include
#include
#include
#include
std::mutex my_lock;
void add(int &num, int &sum){
while(true){
std::lock_guard lock(my_lock);
if (num < 100){ //运行条件
num += 1;
sum += num;
}
else { //退出条件
break;
}
}
}
int main(){
int sum = 0;
int num = 0;
std::vector ver; //保存线程的vector
for(int i = 0; i < 20; ++i){
std::thread t = std::thread(add, std::ref(num), std::ref(sum));
ver.emplace_back(std::move(t)); //保存线程
}
std::for_each(ver.begin(), ver.end(), std::mem_fn(&std::thread::join)); //join
std::cout << sum << std::endl;
}
3. std::unique_lock 用例
类 unique_lock 是通用互斥包装器，允许延迟锁定、锁定的有时限尝试、递归锁定、所有权转移和与条件变量一同使用。
unique_lock比lock_guard使用更加灵活，功能更加强大。
使用unique_lock需要付出更多的时间、性能成本。
下面是try_lock的使用例子。
#include // std::cout
#include // std::thread
#include // std::mutex, std::unique_lock
#include
std::mutex mtx; // mutex for critical section
std::once_flag flag;
void print_block (int n, char c) {
//unique_lock有多组构造函数, 这里std::defer_lock不设置锁状态
std::unique_lock my_lock (mtx, std::defer_lock);
//尝试加锁, 如果加锁成功则执行
//(适合定时执行一个job的场景, 一个线程执行就可以, 可以用更新时间戳辅助)
if(my_lock.try_lock()){
for (int i=0; i ver;
int num = 0;
for (auto i = 0; i < 10; ++i){
ver.emplace_back(print_block,50,'*');
ver.emplace_back(run_one, std::ref(num));
}
for (auto &t : ver){
t.join();
}
std::cout << num << std::endl;
return 0;
}