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;
}
程序运行结果：
此外还有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可以保证多个线程对该函数只调用一次.