【C++11多线程入门教程】系列之互斥量mutex(补)

最新推荐文章于 2025-05-03 11:15:00 发布

原创最新推荐文章于 2025-05-03 11:15:00 发布 · 417 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

C++ Threads

本文围绕C++11的互斥量锁展开，介绍了递归锁recursive_mutex可解决函数内部递归嵌套调用的死锁问题；时长锁timed_mutex能判断一段时间内能否拿到锁；递归时长锁recursive_timed_mutex避免程序拿不到锁而无法结束。还总结了各类互斥量的特点。

互斥量递归锁 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。