C++多线程高并发，mutex，recursive_mutex,timed_mutex,recursive_timed_mutex

mutex

独占互斥量，只能加锁一次，不够人性化，我就是想加锁多次

std::mutex globalMutex;

recursive_mutex

递归的独占互斥量，允许同一个线程，同一个互斥量，多次被lock，用法和非递归的一样 跟windows的临界区是一样的，但是调用次数是有上限的，效率也低一些

std::recursive_mutex globalRecursiveMutex;

timed_mutex

带超时的互斥量,独占互斥量 这个就是拿不到锁会等待一段儿时间，但是超过设定时间，就继续执行

std::timed_mutex globalTimedMutex;

recursive_timed_mutex

带超时的，递归的，独占互斥量，允许同一个线程，同一个互斥量，多次被lock，用法和非递归的一样

std::recursive_timed_mutex globalRecursiveTimedMutex;

尝试试验

• mutex不能在同一个线程中多次加锁的试验，运行出错

std::mutex globalMutex;

void testMethod2()
{
	std::unique_lock<std::mutex> myUniqueLock2(globalMutex);


}

void testMethod1()
{
	std::unique_lock<std::mutex> myUniqueLock(globalMutex);
	testMethod2();
}


int main()
{
	std::thread myThread1(testMethod1);
	myThread1.join();
	return 0;
}

• recursive_mutex 能在同一个线程中多次加锁的试验，程序正常结束

std::recursive_mutex globalRecursiveMutex;

void testMethod2()
{
	std::unique_lock<std::recursive_mutex> myUniqueLock2(globalRecursiveMutex);


}

void testMethod1()
{
	std::unique_lock<std::recursive_mutex> myUniqueLock2(globalRecursiveMutex);
	testMethod2();
}


int main()
{
	std::thread myThread1(testMethod1);
	myThread1.join();
	return 0;
}

recursive_timed_mutex/timed_mutex的几个函数

try_lock_for();是等待一段时间，参数是时间段
try_lock_until();参数是一个时间点，到那个时间点之前等待获取锁，

举例说明

#include <iostream>
#include <atomic>
#include <thread>
#include <future>

std::timed_mutex globalTimedMutex;

void testMethod2()
{
	std::cout << "输出这句话是为了让另一个线程拿到锁" << std::endl;

	while (true)
	{
	//这里使用的try_lock_until的函数，一直等到某个时间点，这里用的是
	//当前时间点+1秒
	//如果换成try_lock_for()直接写std::chrono::milesconds(1000)；
	//就是等待1秒的时间段
	if(globalTimedMutex.try_lock_until(std::chrono::steady_clock::now() + std::chrono::milliseconds(1000)))
		{
			std::cout << "线程" << std::this_thread::get_id() << "拿到超时互斥锁" << std::endl;
			globalTimedMutex.unlock();
			break;
		}
		else
		{
			std::cout << "线程" << std::this_thread::get_id() << "尝试拿锁，但是本次没有拿到互斥锁" << std::endl;
		}
	}
}

//线程二的入口函数，这里让线程休眠10秒，以便观察线程一的效果
void testMethod1()
{
	globalTimedMutex.lock();
	std::this_thread::sleep_for(std::chrono::milliseconds(10000));
	globalTimedMutex.unlock();
}


int main()
{
	std::thread myThread1(testMethod1);
	std::thread myThread2(testMethod2);
	myThread1.join();
	myThread2.join();

	return 0;
}