互斥量：mutex是一个类，有着成员函数lock()和unlock()；用于在多线程中，防止多个线程在同一时间内对某一个变量进行修改。
lock()；加锁，使得当前互斥量的其他lock进入等待，直到我unlock。lock（）必须与unlock（）配套使用，如同new与delete。不能对某个互斥量连续调用多次lock（）或者unlock（）。
unlock（）；解锁。注意，lock（）必须要和unlock（）配套使用，特别是在if语句里面的return前面不要忘记加上unlock（），不然lock（）后面的部分会被锁住，其他线程可能会一直在等待。
粒度：粗略表示lock（）与unlock（）之间的代码段数量，数量越多，粒度越粗，效率越低，否则粒度越细，效率越高。
如下例子中，若temp1的线程运行到第八行的my_mutex.lock（）与第十一行的my_mutex.unlock（）之间，则temp2的线程会到达my_mutex.lock（）时进入等待，直到temp1的线程运行到my_mutex.unlock（）后将锁解开，temp2的线程才能获取到锁后继续运行。
class A {
private:
int a;
mutex my_mutex; //互斥量
public:
void temp1(int &num) {
for (int i = 0; i < 100; i++) {
my_mutex.lock(); //加锁
a = num++;
cout << "调用temp1，a = " << a << endl;
my_mutex.unlock(); //解锁
}
}
void temp2(int &num) {
for (int i = 0; i < 100; i++) {
my_mutex.lock(); //加锁
a = num--;
cout << "调用temp2，a = " << a << endl;
my_mutex.unlock(); //解锁
}
}
};lock_guard；可以在调用析构函数时自动解锁，防止忘记unlock导致的错误。注意，使用lock_guard类型的互斥量没有unlock这个函数，所以不能调用unlock()。
用法一：lock_guard<mutex> lock1(my_mutex); //用于即将加锁的时候，若已经加过锁记得用用法二。lock1只是名称，可以随便取，my_mutex表示的是lock1所绑定的互斥量。
用法二：lock_guard<mutex> lock1(my_mutex, adopt_lock); //第二个参数（adopt_lock）说明my_mutex已经加锁过了，所以在使用前要确保已经给my_mutex加锁。
class A {
private:
int a;
mutex my_mutex;
public:
void temp1(int &num) {
for (int i = 0; i < 100; i++) {
lock_guard<mutex> lock1(my_mutex); //使用用法一
a = num++;
cout << "调用temp1，a = " << a << endl;
}
}
void temp2(int &num) {
for (int i = 0; i < 100; i++) {
my_mutex.lock(); //使用用法二前要先用互斥量加锁
lock_guard<mutex> lock1(my_mutex, adopt_lock); //用法二
a = num--;
cout << "调用temp2，a = " << a << endl;
}
}
};unique_lock；unique_lock也会在析构函数中自动调用unlock（），几个常见用法如下
用法一：unique_lock<mutex> lock1(my_mutex); //用于即将加锁的时候，若该互斥量已经加过锁就不能这样。lock1只是名称，可以随便取，my_mutex表示的是lock1所绑定的互斥量。
用法二：unique_lock<mutex> lock1(my_mutex， adopt_lock); //第二个参数(adopt_lock)说明已经加锁了，在使用前要先给my_mutex加锁。
用法三：unique_lock<mutex> lock1(my_mutex， try_to_lock); //第二个参数表示尝试去加锁，如果my_mutex未加锁就给他加锁，否则什么也不做。调用owns_lock()来获取尝试加锁是否成功，true表示尝试加锁成功，即之前未加锁。
用法四：unique_lock<mutex> lock1(my_mutex， defer_lock); //第二个参数表示初始化了一个没有加锁的互斥量my_mutex（注意，在此前不能用该互斥量加锁），可以用来调用unique_lock中的成员函数。
扩展：通过用法四调用unique_lock中的成员函数。
一：lock（）， lock1.lock()，用于加锁
二：unlock（）, lock1.unlock()，用于解锁（然而一般情况下并不需要主动解锁）
三：try_lock()，lock1.try_lock(),尝试加锁，返回true表示尝试加锁成功，成功加锁；false表示尝试加锁失败。
四：release（），lock1.release(),返回对应的mutex指针，用于解除unique_lock与其对应的mutex之间的关系，release后不会自动解锁了，所以要记得调用my_mutex的unlock解锁。
用法五：unique_lock<mutex> lock1(my_mutex); unique_lock<mutex> lock2(move(lock1)); //将lock1所绑定的mutex转移到lock2，相当于lock1先release再对lock2使用用法一。效果同用法一。
class A {
private:
int a;
mutex my_mutex;
mutex my_mutex1;
public:
void temp1(int &num) { //用法一
for (int i = 0; i < 100; i++) {
lock_guard<mutex> lock1(my_mutex);
a = num++;
cout << "调用temp1，a = " << a << endl;
}
}
void temp2(int &num) { //用法二
for (int i = 0; i < 100; i++) {
my_mutex.lock();
unique_lock<mutex> lock1(my_mutex, adopt_lock);
a = num--;
cout << "调用temp2，a = " << a << endl;
lock1.unlock();
}
}
void temp3(int& num) { //用法三
for (int i = 0; i < 100; i++) {
unique_lock<mutex> lock1(my_mutex, try_to_lock);
if (lock1.owns_lock()) {
a = num--;
cout << "调用temp3，a = " << a << endl;
lock1.unlock();
}
else {
cout << "加锁失败" << endl;
}
}
}
void temp4(int& num) { //用法四
for (int i = 0; i < 100; i++) {
unique_lock<mutex> lock1(my_mutex, defer_lock);
lock1.lock(); //扩展
lock1.unlock();
if (lock1.try_lock()) {
a = num--;
cout << "调用temp2，a = " << a << endl;
lock1.unlock();
}
else {
cout << "加锁失败" << endl;
}
mutex* ptr = lock1.release();
ptr->try_lock(); //不确定之前有无加锁，所以尝试加锁，结果一定是加锁。
ptr->unlock();
}
}
void temp5(int& num) { //用法五
for (int i = 0; i < 100; i++) {
unique_lock<mutex> lock1(my_mutex);
unique_lock<mutex> lock2(move(lock1));
if (lock1.owns_lock()) {
a = num--;
cout << "调用temp2，a = " << a << endl;
lock1.unlock();
}
else {
cout << "加锁失败" << endl;
}
}
}
};unique_lock与lock_guard的区别：
unique_lock比较灵活，但是内存占用会多一点，速度会慢一点。
unique_lock可以使用move移动mutex（见上述用法五）。
recursive_mutex: 递归的独占互斥量（效率比mutex低）。recursive_mutex可以解决在一个线程中多次使用同一个互斥量加锁的情况。由于mutex是独占互斥量，所以如果在一个加锁的函数中调用另一个加锁的函数会导致死锁，即线程未解锁又请求加锁造成堵塞。这时将mutex替换成recursive_mutex就可以解决，用法与mutex同样。可以lock、unlock、unique_lock、lock_guard。但是有递归次数限制，具体的希望大佬可以告知。
class A {
private:
recursive_mutex mutex1;
public:
//函数1
void hanshu1() {
lock_guard<recursive_mutex> lock1(mutex1);
mutex1.lock(); //在同一线程中可以多次上锁
cout << "调用函数1，线程id = " << this_thread::get_id() << endl;
hanshu2(); //这个和函数1在同一个线程内哦。
mutex1.unlock();
}
//函数2
void hanshu2() {
unique_lock<recursive_mutex> lock2(mutex1);
cout << "调用函数2，线程id = " << this_thread::get_id() << endl;
}
};
int main() {
A a;
thread thread1(&A::hanshu1, &a);
thread thread2(&A::hanshu2, &a);
thread1.join();
thread2.join();
return 0;
}timed_mutex、recursive_timed_mutex:带超时的的互斥量和带超时的递归互斥量，这两个差不多，以timed_mutex为例，具有成员函数lock、try_lock、try_lock_for和try_lock_until。前两个与mutex的使用并无差别；后两个是特有的，返回值为bool类型。try_lock_for的参数是一段时间，常用的有chrono::milliseconds和chrono::seconds，即毫秒和秒。在这段时间内如果成功上锁，则返回true；若直到等待时间结束都未上锁，则返回false。try_lock_until与其作用相同，唯一的区别就是参数，它的参数是chrono::system_clock::time_point,即未来的一个时间点（如chrono::steady_clock::now()+chrono::second(5)，即现在（运行开始）的时间再加上5秒）。注意，这两个要自己unlock()。
class A {
private:
timed_mutex mutex1;
public:
//函数1
void hanshu1() {
if (mutex1.try_lock_for(chrono::milliseconds(10))) {
cout << "调用函数1，线程id = " << this_thread::get_id() << endl;
mutex1.unlock();
}
}
//函数2
void hanshu2() {
if (mutex1.try_lock_until(chrono::steady_clock::now()+ chrono::milliseconds(10))) {
cout << "调用函数2，线程id = " << this_thread::get_id() << endl;
mutex1.unlock();
}
}
};
int main() {
A a;
thread thread1(&A::hanshu1, &a);
thread thread2(&A::hanshu2, &a);
thread1.join();
thread2.join();
return 0;
}死锁问题：
互斥量加锁时的顺序问题，比如现在有两个线程t1和t2，t1先用mutex1加锁，再用mutex2加锁，而t2先用mutex2加锁，再用mutex1加锁，由于线程是同步运行的，所以可能出现t1用mutex1加锁后，t2已经用mutex2加锁了，t1需要等待t2的mutex2解锁，而t2需要等待t1的mutex1解锁，造成死锁。解决办法：使用lock函数。
lock（）；用于给多个互斥量时的同时加锁，消除互斥量加锁的顺序问题，但需要主动调用互斥量解锁。
lock(mutex1, mutex2, mutex3, ...)。
323
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
