互斥量递归锁 recursive_mutex
递归锁recursive_mutex
使用方法类似于mutex
,主要解决的是在同一个互斥量对象,在函数内部递归嵌套调用时候导致的死锁情况。这个时候使用recursive_mutex
可以解决这个问题。
#include <iostream>
#include <mutex>
#include <thread>
//std::mutex mtx;
std::recursive_mutex mtx;
void eat_fish()
{
//if (mtx.try_lock())
//{
// std::cout << "I eat fish." << std::this_thread::get_id() << std::endl;
// mtx.unlock();
//}
//else
//{
// std::cout << "no lock fish.\n";
//}
mtx.lock();
std::cout << "I eat fish." << std::this_thread::get_id() << std::endl;
mtx.unlock();
}
void eat_rice()
{
//if (mtx.try_lock())
//{
// std::cout << "I eat rice." << std::this_thread::get_id() << std::endl;
// eat_fish();
// mtx.unlock();
//}
//else
//{
// std::cout << "no lock rice.\n";
//}
mtx.lock();
std::cout << "I eat rice." << std::this_thread::get_id() << std::endl;
eat_fish();
mtx.unlock();
}
int main(void)
{
std::thread eat_f(eat_fish);
std::thread eat_r(eat_rice);
eat_f.join();
eat_r.join();
system("pause");
return 0;
}
我们看下面的运行结果:
I eat fish.14820
I eat rice.14816
I eat fish.14816
从上面的结果可以正常运行,如果你更换互斥锁mutex的话,将会报错。主要原因在于:当我们调用线程函数eat_rice()
时候会对其上锁,内部又调用eat_fish()
函数。如果在线程调用eat_rice()时候,这个时候eat_fish()
也被调用,这样在eat_rice()
内部再次调用eat_fish()
将会产生死锁。我们通过使用recursive_mutex
可以看到,函数eat_rice()
内部调用函数eat_fish()
但是线程都是相同的id,这说明是同一个线程在调用此时的eat_r。
互斥量时长锁 timed_mutex
时间长锁,主要是针对互斥量在一段时间内是否能够拿到锁进行判断。主要函数为try_lock_for()
与try_lock_until()
两个函数。其中try_lock_for()
函数传入的参数为时间长度duaration,而try_lock_until()
传入的为固定的时间点。示例见下面的代码程序部分:
// timed_mutex::try_lock_for example
#include <iostream> // std::cout
#include <chrono> // std::chrono::milliseconds
#include <thread> // std::thread
#include <mutex> // std::timed_mutex
std::timed_mutex mtx;
void fireworks() {
// waiting to get a lock: each thread prints "-" every 200ms:
while (!mtx.try_lock_for(std::chrono::milliseconds(200))) {
std::cout << "-";
}
// got a lock! - wait for 1s, then this thread prints "*"
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
std::cout << "*\n";
mtx.unlock();
}
int main()
{
std::thread threads[10];
// spawn 10 threads:
for (int i = 0; i < 10; ++i)
threads[i] = std::thread(fireworks);
for (auto& th : threads) th.join();
return 0;
}
互斥量timed_mutex
使用try_lock_until()
测试示例:
#include <iostream>
#include <atomic>
#include <thread>
#include <future>
std::timed_mutex time_mtx;
void testCase2()
{
while (true)
{
if (time_mtx.try_lock_until(std::chrono::steady_clock::now() + std::chrono::milliseconds(1000)))
{
std::cout << "线程" << std::this_thread::get_id() << "拿到互斥锁." << std::endl;
time_mtx.unlock();
break;
}
else
{
std::cout << "线程" << std::this_thread::get_id() << "尝试拿锁,但本次没有拿到互斥锁" << std::endl;
}
}
}
void testCase1()
{
time_mtx.lock();
// testCase1 让线程休眠10秒,以便观察线程 testCase2函数 的效果
std::this_thread::sleep_for(std::chrono::milliseconds(10000));
time_mtx.unlock();
}
int main()
{
std::thread testCase1Thread(testCase1);
std::thread testCase2Thread(testCase2);
testCase1Thread.join();
testCase2Thread.join();
system("pause");
return 0;
}
互斥量递归时长锁 recursive_timed_mutex
下面代码主要介绍recursive_timed_mutex
递归时长互斥锁的使用,如果你换成使用timed_mutex
互斥锁,那么有可能程序一直无法结束,try_lock_until()
一直无法拿到锁的情况出现。
#include <iostream>
#include <atomic>
#include <thread>
#include <future>
//std::timed_mutex time_mtx;
std::recursive_timed_mutex time_mtx;
void testCase2()
{
while (true)
{
if (time_mtx.try_lock_until(std::chrono::steady_clock::now() + std::chrono::milliseconds(1000)))
{
std::cout << "线程" << std::this_thread::get_id() << "拿到互斥锁." << std::endl;
time_mtx.unlock();
break;
}
else
{
std::cout << "线程" << std::this_thread::get_id() << "尝试拿锁,但本次没有拿到互斥锁" << std::endl;
}
}
}
void testCase1()
{
time_mtx.lock();
// testCase1 让线程休眠10秒,以便观察线程 testCase2函数 的效果
std::this_thread::sleep_for(std::chrono::milliseconds(10000));
testCase2();
time_mtx.unlock();
}
int main()
{
std::thread testCase1Thread(testCase1);
std::thread testCase2Thread(testCase2);
testCase1Thread.join();
testCase2Thread.join();
system("pause");
return 0;
}
小结
这里我们来简单总结一下关于互斥量的相关使用:
- mutex 独占互斥量,只能够加锁一次,不够灵活性,同时使用容易忘记解锁;
- lock_guard 加锁保护互斥量,能够有效避免忘记解锁的问题,但是灵活性也不好;
- unique_lock 加锁保护互斥量,灵活性好,功能丰富,能够灵活加解锁,但是复杂度也有所提高;
- recursive_mutex 递归独占互斥量,优点是允许同一个线程,同一个互斥量,多次被lock和unlcok。与windows的临界区原理类似,但调用次数是有上限的,效率较lock_guard低;
- timed_mutex 带超时的互斥量,独占互斥量。 拿不到锁会等待一段时间,若超过设定时间,就继续执行。
- recursive_timed_mutex 带超时的,递归的,独占互斥量,允许同一个线程,同一个互斥量,多次被lock与unlock。