C++:mutex库

一、C++的mutex库
互斥量
C++11中提供了std::mutex互斥量,共包含四种类型:
std::mutex:最基本的mutex类。
std::recursive_mutex:递归mutex类,能多次锁定而不死锁。
std::time_mutex:定时mutex类,可以锁定一定的时间。
std::recursive_timed_mutex:定时递归mutex类。

1、mutex
在多线程环境中,有多个线程竞争同一个公共资源,就很容易引发线程安全的问题。因此就需要引入锁的机制,来保证任意时候只有一个线程在访问公共资源。
首先我们来看这样一段代码:

#include
#include
#include

void Add(int* px, int n)
{
	for (int i = 0; i < n; i++)
	{
		(*px)++;
	}
}

void Fun()
{
	int x = 0;
	std::cout << "Before Add:x=" << x << std::endl;
	std::thread t1(Add, &x, 10000000);
	std::thread t2(Add, &x, 10000000);
	t1.join();
	t2.join();
	std::cout << "After Add:x=" << x << std::endl;
	std::cout << "----------------------------"<

在上面的代码中,我么起两个线程,对变量x加加,在数据量在小的时候,是没啥问题的,但是数据量比较大的时候,在我的机器d到达千万次时,就会出现问题,而且多次执行,每次的结果都是不同的。

那这个时候我们就想到了加锁来解决,但是加锁有产生了两种不同的加锁方式
方式一:

void Add1(int* px, int n,std::mutex* pmt)
{
	(*pmt).lock();
	for (int i = 0; i < n; i++)
	{
		(*px)++;
	}
	(*pmt).unlock();
}

方式二

void Add2(int* px, int n, std::mutex* pmt)
{
	for (int i = 0; i < n; i++)
	{
		(*pmt).lock();
		(*px)++;
		(*pmt).unlock();
	}
}

然后我们执行下面的代码,对这两种不同的加锁方式进行计时;

#include
#include
#include
#include

void Add1(int* px, int n,std::mutex* pmt)
{
	(*pmt).lock();
	for (int i = 0; i < n; i++)
	{
		(*px)++;
	}
	(*pmt).unlock();
}

void Add2(int* px, int n, std::mutex* pmt)
{
	for (int i = 0; i < n; i++)
	{
		(*pmt).lock();
		(*px)++;
		(*pmt).unlock();
	}
}

void Fun1()
{
	int x = 0;
	std::cout << "Before Add:x=" << x << std::endl;
	std::mutex mt;
	std::thread t1(Add1, &x, 10000000,&mt);
	std::thread t2(Add1, &x, 10000000,&mt);
	t1.join();
	t2.join();
	std::cout << "After Add:x=" << x << std::endl;
}
void Fun2()
{
	int y = 0;
	std::cout << "Before Add:y=" << y << std::endl;
	std::mutex mt;
	std::thread t1(Add2, &y, 10000000, &mt);
	std::thread t2(Add2, &y, 10000000, &mt);
	t1.join();
	t2.join();
	std::cout << "After Add:y=" << y << std::endl;
}
int main()
{
	int start1 = clock();
	Fun1();
	int end1 = clock();
	std::cout << "Fun1 Time Spend:" << end1 - start1 << std::endl;

	int start2 = clock();
	Fun2();
	int end2 = clock();
	std::cout << "Fun2 Time Spend:" << end2 - start2 << std::endl;
	system("pause");
	return 0;
}
// 执行结果
Before Add:x=0
After Add:x=20000000
Fun1 Time Spend:89
Before Add:y=0
After Add:y=20000000
Fun2 Time Spend:7795

可以看出相同的代码,由于加锁的粒度不同的,其执行的时间的差异是非常大的。

这是因为,第一种加锁方式中,第一个线程进去后,另一个线程阻塞休眠,在第一个线程完成循环后,在唤醒另外一个线程。而第二个线程则是在循环中加加一次后,有可能就会让另外一个线程执行。而我们知道CPU的运算速度是非常快的,频繁的加锁解锁,进行线程的切换(cpu进程调度:需要保存当前进程的上下文)都需要耗费时间,因此第二种加锁方式相比于第一种会慢很多。

而在上面的程序中我么使用的是互斥锁,而互斥锁是适用于锁的粒度比较大的场景使用的,而对于锁的粒度比较小的场景,我们可以使用自旋锁。

那互斥所和自旋锁有什么区别呢?其各自的使用场景是怎样的?
互斥锁:
lock() :第一个线程进去后,后面的线程会进入阻塞休眠状态,被放入到阻塞队列中。
unlock():加锁的线程执行完后,会解锁,然后去阻塞队列中唤醒阻塞线程
适用于锁的粒度大的场景

自旋锁:
lock():第一个线程进去,后面的线程在循环空转检查。
unlock():第一个加锁的线程解锁,后面的线程检测到就可以被cpu调度。

举个例子就很好理解:快递。
互斥锁就好比,你去取快递的地方问了一下,你的快递还有1天才能到,你就可以先把电话留在取快递的地方,等你的快递到了,快递公司的工作人员会打电话通知你,而这种场景如果使用自旋锁,就好比每隔几分钟就去询问快递工作人员,我觉得快递人员只能说:what’s your problem?(宏颜祸水)。

自旋锁就像,你去问的时候,你的快递还有大概20分钟就到了,那这20分钟也干不了啥,还不如就在快递点等着,玩玩手机,每隔5分钟去问一下,快递到了没。而这种场景如果使用互斥锁,那你就会觉的还有20分钟,不如回家等着快递人员给我打电话吧,结果你刚走到家门口,把钥匙插入锁,快递公司打电话告知:你的快递到了。

而类比到计算机:使用互斥锁就好比让其他线程阻塞,进入阻塞队列,就类似你回家等通知。
使用自旋锁就让其它线程空转(比如可以给该线程设置在一定时间段内让出cpu使用权),每隔10毫秒检查一次,就类似你在快递点的门口等待,每隔5分钟去问一下,快递到了没。

2、recursive_mutex
先来看一段代码:

std::mutex mt;  

int n = 10;

void Fun()
{
	if (n == 0)
		return;
	mt.lock();
	n -= 1;
	Fun();
	mt.unlock();
}
int main()
{
	Fun();
	std::cout << n << std::endl;
	system("pause");
	return 0;
}
// 运行结构
0

在上面的程序中,Fun函数中有调用Fun()函数,会对mt多次加锁。而std::mutex是个非递归锁,这个程序会立刻死锁。而这时候使用mutex库中的recursive_mutex就可以避免程序死锁。

而递归锁的实现,也比较简单,只需要在非递归锁的基础上,引入引用计数就可以解决了。下面模拟实现一个简单的递归锁。

#include
#include
#include
#include
#include

int g_num = 0;
std::recursive_mutex rmt;

class RecursiveMutex
{
public:
	RecursiveMutex()
		:lock_nums(0)
	{
	}
	~RecursiveMutex() {}
	void lock(){
		if (lock_nums == 0){
			my_mutex.lock();
			owner_thread_id = std::this_thread::get_id();
			lock_nums++;
		}
		else if (std::this_thread::get_id() == owner_thread_id)
			lock_nums++;
		else{
			my_mutex.lock();
			owner_thread_id = std::this_thread::get_id();
			lock_nums++;
		}
	}
	void unlock()
	{
		if (lock_nums > 0)
			lock_nums--;
		if (lock_nums == 0)
			my_mutex.unlock();
	}

private:
	int lock_nums = 0;
	std::mutex my_mutex;
	std::thread::id owner_thread_id;
};

RecursiveMutex RMT;
std::lock_guard lg(RMT);

void SlowAddStl(int id)
{
	for (int i = 0; i < 3; i++){
		rmt.lock();
		++g_num;
		std::cout << id << "=>" << g_num << std::endl;
		rmt.unlock();
		std::this_thread::sleep_for(std::chrono::seconds(2));
	}
}

void SlowAdd(int id)
{
	for (int i = 0; i < 3; i++){
		RMT.lock();
		++g_num;
		std::cout << id << "=>" << g_num << std::endl;
		RMT.unlock();
		std::this_thread::sleep_for(std::chrono::seconds(2));
	}
}

int main()
{
	std::cout << "使用stl中的recursive_mutex" << std::endl;
	std::thread t1(SlowAddStl, 0);
	std::thread t2(SlowAddStl, 1);
	t1.join();
	t2.join();

	std::cout << "使用自己实现的RecursiceMutex" << std::endl;
	std::thread t3(SlowAdd, 0);
	std::thread t4(SlowAdd, 1);
	t3.join();
	t4.join();
	system("pause");
	return 0;
}

程序运行结果:
C++:mutex库_第1张图片
此外还有timed_mutex和recursive_timed_mutex分别是可以设置时间的非递归互斥量和递归互斥量,有时间在演示吧。

C++11中提供了std::mute锁,共包含两种类型:
std::lock_guard:方便线程对互斥量上锁。
std::unique_lock:方便线程对互斥量上锁,但提供了更好的上锁和解锁控制。
以及相关的函数:

1、lock_guard
先来看一段代码:

#include
#include
#include
#include

std::mutex mt;

void PrintEven(int x)
{
	if (x % 2 == 0)
		std::cout << x << "is even\n";
	else
		throw ("not even");
}
void PrintThreadId(int id)
{
	try{
		mt.lock();
		PrintEven(id);
		mt.lock();
	}
	catch (std::string& e)
	{
		std::cout << "[" << e << "]\n";
	}
}
int main()
{
	std::thread threads[5];
	for (int i = 0; i < 5; i++)
		threads[i] = std::thread(PrintThreadId, i + 1);
	for (auto& th : threads)
		th.join();
	return 0;
}

上面的程序中会崩溃,因为线程在执行PrintThreadId函数时,先加锁,然后在调用PrintEven函数,有可能会抛出异常,而在PrintThreadID函数中捕获异常,导致该线程并没有解锁,导致死锁问题。

那这个时候就可以使用lock_guard解决上面的问题。lock_guard是基于RAII思想的一种产物,即把锁的生命周期交给lcok_guard实例化的对象去管理。而且在lock_guard类只有两个成员函数,构造和析构函数。
在这里插入图片描述
只需要对代码做出如下的修改就好了。

void PrintThreadId(int id)
{
	try{
		std::lock_guard lg(mt);
		PrintEven(id);
	}
	catch (...)
	{
		std::cout << "[exception caught]\n";
	}
}

2、unique_lock
unique_lock相比于lock_guard,都是基于RAII思想的,也支持std::lock_guard的功能,但是区别在于它提供更多的成员函数,比如:lock(),unlock()使用更加灵活,并且可以和condiction_variable一起使用控制线程同步。

#include 
#include     
#include       

std::mutex mtx;  

void print_block (int n, char c) {
  std::unique_lock lck (mtx);
  for (int i=0; i

还提供了这些函数:
std::try_lock:尝试同时对多个互斥量上锁
std::lock:可以同时对多个互斥量上锁
std::call_one:如果多个线程需要同时调用某个函数,call_one可以保证多个线程对该函数只调用一次.

你可能感兴趣的:(C++:mutex库)