互斥量: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, ...)。