六、unique_lock(类模板)详解
1.unique_lock取代lock_guard
- unique_lock比lock_guard灵活很多(多出来很多用法),效率差一点,内存占用多一点。
unique_lock<mutex> myUniLock(myMutex);
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <list>
#include <thread>
#include <mutex>
using namespace std;
class A
{
public:
//把收到的消息(玩家命令)插入到一个队列的线程
void inMesgRecvQueue()
{
for (int i = 0; i < 100000; ++i)
{
cout << "inMesgRecvQueue执行,插入一个元素" << i << endl;
//my_mutex1.lock();
//其他处理...
//my_mutex2.lock();
std::lock(my_mutex1, my_mutex2);
//std::lock_guard<std::mutex> my_lock_guard1(my_mutex1, std::adopt_lock);
//std::lock_guard<std::mutex> my_lock_guard2(my_mutex2, std::adopt_lock);//加上这两行就不用unlock()了
std::unique_lock<std::mutex> my_lock_guard1(my_mutex1, std::adopt_lock);
std::unique_lock<std::mutex> my_lock_guard2(my_mutex2, std::adopt_lock);//加上这两行就不用unlock()了
list_msg.push_back(i);
//my_mutex2.unlock();
//my_mutex1.unlock();
//其他处理。。。。
}
}
//把消息队列从容器中取出来的线程
void outMesgRecvQueue()
{
for (int i = 0; i < 100000; ++i)
{
if (!list_msg.empty())
{
int command = list_msg.front();
//my_mutex1.lock();
//my_mutex2.lock();
std::lock(my_mutex1, my_mutex2);//std::lock(my_mutex2, my_mutex2);
list_msg.pop_front();
my_mutex1.unlock();
my_mutex2.unlock();
}
else
{
cout << "消息队列为空" << endl;
}
}
cout << "outMesgRecvQueue end" << endl;
}
protected:
private:
std::list<int> list_msg;//专门用于代表玩家给咱们发送过来的命令
std::mutex my_mutex1;//创建了一个互斥量
std::mutex my_mutex2;//创建了一个互斥量
};
int main(int argc, char* argv[])
{
A myobja;
//第2个参数是引用,才能保证线程里面用的是同一个对象
std::thread myOutMsgobj(&A::outMesgRecvQueue, &myobja);
std::thread myInMsgobj(&A::inMesgRecvQueue, &myobja);
myOutMsgobj.join();
myInMsgobj.join();
system("pause");
return 0;
}
2.unique_lock的第二个参数
2.1 std::adopt_lock:
- 表示这个互斥量已经被lock(),即不需要在构造函数中lock这个互斥量了。
- 前提:
必须提前lock
- lock_guard中也可以用这个参数
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <list>
#include <thread>
#include <mutex>
using namespace std;
class A
{
public:
//把收到的消息(玩家命令)插入到一个队列的线程
void inMesgRecvQueue()
{
for (int i = 0; i < 100000; ++i)
{
cout << "inMesgRecvQueue执行,插入一个元素" << i << endl;
//my_mutex1.lock();
//其他处理...
//my_mutex2.lock();
std::lock(my_mutex1, my_mutex2);//必须先加锁,才能使用unique_lock的std::adopt_lock
//std::lock_guard<std::mutex> my_lock_guard1(my_mutex1, std::adopt_lock);
//std::lock_guard<std::mutex> my_lock_guard2(my_mutex2, std::adopt_lock);//加上这两行就不用unlock()了
std::unique_lock<std::mutex> my_unique_lock1(my_mutex1, std::adopt_lock);
std::unique_lock<std::mutex> my_unique_lock2(my_mutex2, std::adopt_lock);//加上这两行就不用unlock()了
list_msg.push_back(i);
//my_mutex2.unlock();
//my_mutex1.unlock();
//其他处理。。。。
}
}
//把消息队列从容器中取出来的线程
void outMesgRecvQueue()
{
for (int i = 0; i < 100000; ++i)
{
if (!list_msg.empty())
{
int command = list_msg.front();
//my_mutex1.lock();
//my_mutex2.lock();
std::lock(my_mutex1, my_mutex2);//std::lock(my_mutex2, my_mutex2);
list_msg.pop_front();
my_mutex1.unlock();
my_mutex2.unlock();
}
else
{
cout << "消息队列为空" << endl;
}
}
cout << "outMesgRecvQueue end" << endl;
}
protected:
private:
std::list<int> list_msg;//专门用于代表玩家给咱们发送过来的命令
std::mutex my_mutex1;//创建了一个互斥量
std::mutex my_mutex2;//创建了一个互斥量
};
int main(int argc, char* argv[])
{
A myobja;
//第2个参数是引用,才能保证线程里面用的是同一个对象
std::thread myOutMsgobj(&A::outMesgRecvQueue, &myobja);
std::thread myInMsgobj(&A::inMesgRecvQueue, &myobja);
myOutMsgobj.join();
myInMsgobj.join();
system("pause");
return 0;
}
2.2 std::try_to_lock:
- 尝试用mutex的lock()去锁定这个mutex,但如果没有锁定成功,会立即返回,不会阻塞在那里;
使用try_to_lock的原因是防止其他的线程锁定mutex太长时间,导致本线程一直阻塞在lock这个地方
- 前提:
不能提前lock();
owns_locks()方法判断是否拿到锁,如拿到返回true
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <list>
#include <thread>
#include <mutex>
using namespace std;
class A
{
public:
//把收到的消息(玩家命令)插入到一个队列的线程
void inMesgRecvQueue()
{
for (int i = 0; i < 100000; ++i)
{
cout << "inMesgRecvQueue执行,插入一个元素" << i << endl;
//其他处理...
std::unique_lock<std::mutex> my_unique_lock1(my_mutex1, std::try_to_lock);
std::unique_lock<std::mutex> my_unique_lock2(my_mutex2, std::try_to_lock);//加上这两行就不用unlock()了
if (my_unique_lock1.owns_lock() && my_unique_lock2.owns_lock())
{
//拿到锁了
list_msg.push_back(i);
//其他处理。。。。
}
else
{
//没拿到锁
std::cout << "inMesgRecvQueue()执行,但是没拿到锁,继续干其他事情" << std::endl;
}
}
}
//把消息队列从容器中取出来的线程
void outMesgRecvQueue()
{
for (int i = 0; i < 100000; ++i)
{
if (!list_msg.empty())
{
int command = list_msg.front();
//my_mutex1.lock();
//my_mutex2.lock();
std::lock(my_mutex1, my_mutex2);//std::lock(my_mutex2, my_mutex2);
std::chrono::milliseconds dura(20000);
std::this_thread::sleep_for(dura);//卡20秒
list_msg.pop_front();
my_mutex1.unlock();
my_mutex2.unlock();
}
else
{
cout << "消息队列为空" << endl;
}
}
cout << "outMesgRecvQueue end" << endl;
}
protected:
private:
std::list<int> list_msg;//专门用于代表玩家给咱们发送过来的命令
std::mutex my_mutex1;//创建了一个互斥量
std::mutex my_mutex2;//创建了一个互斥量
};
int main(int argc, char* argv[])
{
A myobja;
//第2个参数是引用,才能保证线程里面用的是同一个对象
std::thread myOutMsgobj(&A::outMesgRecvQueue, &myobja);
std::thread myInMsgobj(&A::inMesgRecvQueue, &myobja);
myOutMsgobj.join();
myInMsgobj.join();
system("pause");
return 0;
}
2.3 std::defer_lock
- 如果没有第二个参数就对mutex进行加锁,加上defer_lock是
初始化了一个没有加锁的mutex
- 不给它加锁的目的是以后可以调用unique_lock的一些方法
- 前提:
不能提前lock
3.unique_lock的成员函数(前三个与std::defer_lock联合使用)
3.1 lock():加锁。
不用自己unlock();
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <list>
#include <thread>
#include <mutex>
using namespace std;
class A
{
public:
//把收到的消息(玩家命令)插入到一个队列的线程
void inMesgRecvQueue()
{
for (int i = 0; i < 100000; ++i)
{
cout << "inMesgRecvQueue执行,插入一个元素" << i << endl;
//其他处理...
std::unique_lock<std::mutex> my_unique_lock1(my_mutex1, std::defer_lock);//没有加锁的my_mutex1
my_unique_lock1.lock();//不用自己unlock();
std::unique_lock<std::mutex> my_unique_lock2(my_mutex2, std::defer_lock);//没有加锁的my_mutex2
my_unique_lock2.lock();
list_msg.push_back(i);
//其他处理。。。。
}
}
//把消息队列从容器中取出来的线程
void outMesgRecvQueue()
{
for (int i = 0; i < 100000; ++i)
{
if (!list_msg.empty())
{
int command = list_msg.front();
std::lock(my_mutex1, my_mutex2);//std::lock(my_mutex2, my_mutex2);
list_msg.pop_front();
my_mutex1.unlock();
my_mutex2.unlock();
}
else
{
cout << "消息队列为空" << endl;
}
}
cout << "outMesgRecvQueue end" << endl;
}
protected:
private:
std::list<int> list_msg;//专门用于代表玩家给咱们发送过来的命令
std::mutex my_mutex1;//创建了一个互斥量
std::mutex my_mutex2;//创建了一个互斥量
};
int main(int argc, char* argv[])
{
A myobja;
//第2个参数是引用,才能保证线程里面用的是同一个对象
std::thread myOutMsgobj(&A::outMesgRecvQueue, &myobja);
std::thread myInMsgobj(&A::inMesgRecvQueue, &myobja);
myOutMsgobj.join();
myInMsgobj.join();
system("pause");
return 0;
}
3.2 unlock():解锁。
因为一些非共享代码要处理,可以暂时先unlock(),用其他线程把它们处理了,处理完后再lock()。
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <list>
#include <thread>
#include <mutex>
using namespace std;
class A
{
public:
//把收到的消息(玩家命令)插入到一个队列的线程
void inMesgRecvQueue()
{
for (int i = 0; i < 100000; ++i)
{
cout << "inMesgRecvQueue执行,插入一个元素" << i << endl;
//其他处理...
std::unique_lock<std::mutex> my_unique_lock1(my_mutex1, std::defer_lock);//没有加锁的my_mutex1
my_unique_lock1.lock();
std::unique_lock<std::mutex> my_unique_lock2(my_mutex2, std::defer_lock);//没有加锁的my_mutex2
my_unique_lock2.lock();
//处理共享代码。。。
my_unique_lock1.unlock();//因为有一些非共享代码要处理,所以才手动unlock
my_unique_lock2.unlock();
//处理一些非共享代码。。。
my_unique_lock1.lock();//再次加锁,保护共享数据,处理共享代码。。。不需要手动unclock
my_unique_lock2.lock();
list_msg.push_back(i);
my_unique_lock1.unlock();//这里加不加unclock都可以,生命周期结束,不加的话,my_unique_lock1调用my_mutex1的析构函数unlock
my_unique_lock2.unlock();//加的话,my_unique_lock1不调用my_mutex1的析构函数unlock
//其他处理。。。。
}
}
//把消息队列从容器中取出来的线程
void outMesgRecvQueue()
{
for (int i = 0; i < 100000; ++i)
{
if (!list_msg.empty())
{
int command = list_msg.front();
std::lock(my_mutex1, my_mutex2);//std::lock(my_mutex2, my_mutex2);
list_msg.pop_front();
my_mutex1.unlock();
my_mutex2.unlock();
}
else
{
cout << "消息队列为空" << endl;
}
}
cout << "outMesgRecvQueue end" << endl;
}
protected:
private:
std::list<int> list_msg;//专门用于代表玩家给咱们发送过来的命令
std::mutex my_mutex1;//创建了一个互斥量
std::mutex my_mutex2;//创建了一个互斥量
};
int main(int argc, char* argv[])
{
A myobja;
//第2个参数是引用,才能保证线程里面用的是同一个对象
std::thread myOutMsgobj(&A::outMesgRecvQueue, &myobja);
std::thread myInMsgobj(&A::inMesgRecvQueue, &myobja);
myOutMsgobj.join();
myInMsgobj.join();
system("pause");
return 0;
}
3.3 try_lock():尝试给互斥量加锁
如果拿不到锁,返回false,否则返回true。
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <list>
#include <thread>
#include <mutex>
using namespace std;
class A
{
public:
//把收到的消息(玩家命令)插入到一个队列的线程
void inMesgRecvQueue()
{
for (int i = 0; i < 100000; ++i)
{
cout << "inMesgRecvQueue执行,插入一个元素" << i << endl;
//其他处理...
std::unique_lock<std::mutex> my_unique_lock1(my_mutex1, std::defer_lock);//没有加锁的my_mutex1
std::unique_lock<std::mutex> my_unique_lock2(my_mutex2, std::defer_lock);//没有加锁的my_mutex2
if (my_unique_lock1.try_lock() == true && my_unique_lock2.try_lock() == true)
{
list_msg.push_back(i);
}
else
{
//其他处理。。。。
}
}
}
//把消息队列从容器中取出来的线程
void outMesgRecvQueue()
{
for (int i = 0; i < 100000; ++i)
{
if (!list_msg.empty())
{
int command = list_msg.front();
std::lock(my_mutex1, my_mutex2);//std::lock(my_mutex2, my_mutex2);
std::chrono::milliseconds dura(2000);
std::this_thread::sleep_for(dura);
list_msg.pop_front();
my_mutex1.unlock();
my_mutex2.unlock();
}
else
{
cout << "消息队列为空" << endl;
}
}
cout << "outMesgRecvQueue end" << endl;
}
protected:
private:
std::list<int> list_msg;//专门用于代表玩家给咱们发送过来的命令
std::mutex my_mutex1;//创建了一个互斥量
std::mutex my_mutex2;//创建了一个互斥量
};
int main(int argc, char* argv[])
{
A myobja;
//第2个参数是引用,才能保证线程里面用的是同一个对象
std::thread myOutMsgobj(&A::outMesgRecvQueue, &myobja);
std::thread myInMsgobj(&A::inMesgRecvQueue, &myobja);
myOutMsgobj.join();
myInMsgobj.join();
system("pause");
return 0;
}
3.4 release():
返回它管理的mutex对象指针,并释放所有权,也就是说unique_lock不再与mutex有联系
- unique_lock
- my_unique_lock1(my_mutex1);相当于把my_mutex1和my_unique_lock1绑定在了一起,release()就是解除绑定,返回它所管理的mutex对象的指针,并释放所有权
- mutex* ptx = my_unique_lock1.release();所有权由ptx接管,如果原来mutex对象处理加锁状态,就需要ptx在以后进行解锁了。
- lock的代码段越少,执行越快,整个程序的运行效率越高。
- a.锁住的代码少,叫做粒度细,执行效率高;
- b.锁住的代码多,叫做粒度粗,执行效率低;
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <list>
#include <thread>
#include <mutex>
using namespace std;
class A
{
public:
//把收到的消息(玩家命令)插入到一个队列的线程
void inMesgRecvQueue()
{
for (int i = 0; i < 100000; ++i)
{
cout << "inMesgRecvQueue执行,插入一个元素" << i << endl;
//其他处理...
std::unique_lock<std::mutex> my_unique_lock1(my_mutex1);
std::unique_lock<std::mutex> my_unique_lock2(my_mutex2);
std::mutex *ptx1 = my_unique_lock1.release();
std::mutex *ptx2 = my_unique_lock2.release();
list_msg.push_back(i);
//其他处理。。。。
ptx1->unlock();//自己负责my_mutex1的unlock
ptx2->unlock();//自己负责my_mutex2的unlock
}
}
//把消息队列从容器中取出来的线程
void outMesgRecvQueue()
{
for (int i = 0; i < 100000; ++i)
{
if (!list_msg.empty())
{
int command = list_msg.front();
std::lock(my_mutex1, my_mutex2);//std::lock(my_mutex2, my_mutex2);
list_msg.pop_front();
my_mutex1.unlock();
my_mutex2.unlock();
}
else
{
cout << "消息队列为空" << endl;
}
}
cout << "outMesgRecvQueue end" << endl;
}
protected:
private:
std::list<int> list_msg;//专门用于代表玩家给咱们发送过来的命令
std::mutex my_mutex1;//创建了一个互斥量
std::mutex my_mutex2;//创建了一个互斥量
};
int main(int argc, char* argv[])
{
A myobja;
//第2个参数是引用,才能保证线程里面用的是同一个对象
std::thread myOutMsgobj(&A::outMesgRecvQueue, &myobja);
std::thread myInMsgobj(&A::inMesgRecvQueue, &myobja);
myOutMsgobj.join();
myInMsgobj.join();
system("pause");
return 0;
}
4.unique_lock所有权的传递
- std::unique_lockstd::mutex my_unique_lock1(my_mutex1);//所有权概念
- 把my_unique_lock1和my_mutex1绑定在了一起,也就是my_unique_lock1拥有my_mutex1的所有权
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <list>
#include <thread>
#include <mutex>
using namespace std;
class A
{
public:
//把收到的消息(玩家命令)插入到一个队列的线程
void inMesgRecvQueue()
{
for (int i = 0; i < 100000; ++i)
{
cout << "inMesgRecvQueue执行,插入一个元素" << i << endl;
//其他处理...
std::unique_lock<std::mutex> my_unique_lock1(my_mutex1);//所有权概念
std::unique_lock<std::mutex> my_unique_lock2(my_mutex2);
//std::unique_lock<std::mutex> my_unique_lock12(my_unique_lock1);//复制是非法的
//移动语义,现在相当于my_unique_lock12和my_mutex1绑到一起了
//现在my_unique_lock1指向空,my_unique_lock12指向了my_mutex1
std::unique_lock<std::mutex> my_unique_lock12(std::move(my_unique_lock1));
//移动语义,现在相当于my_unique_lock22和my_mutex2绑到一起了
//现在my_unique_lock2指向空,my_unique_lock22指向了my_mutex1
std::unique_lock<std::mutex> my_unique_lock22(std::move(my_unique_lock2));
//std::mutex *ptx1 = my_unique_lock1.release();
//std::mutex *ptx2 = my_unique_lock2.release();
list_msg.push_back(i);
//其他处理。。。
//ptx1->unlock();//自己负责my_mutex1的unlock
//ptx2->unlock();//自己负责my_mutex2的unlock
}
}
//把消息队列从容器中取出来的线程
void outMesgRecvQueue()
{
for (int i = 0; i < 100000; ++i)
{
if (!list_msg.empty())
{
int command = list_msg.front();
std::lock(my_mutex1, my_mutex2);//std::lock(my_mutex2, my_mutex2);
list_msg.pop_front();
my_mutex1.unlock();
my_mutex2.unlock();
}
else
{
cout << "消息队列为空" << endl;
}
}
cout << "outMesgRecvQueue end" << endl;
}
protected:
private:
std::list<int> list_msg;//专门用于代表玩家给咱们发送过来的命令
std::mutex my_mutex1;//创建了一个互斥量
std::mutex my_mutex2;//创建了一个互斥量
};
int main(int argc, char* argv[])
{
A myobja;
//第2个参数是引用,才能保证线程里面用的是同一个对象
std::thread myOutMsgobj(&A::outMesgRecvQueue, &myobja);
std::thread myInMsgobj(&A::inMesgRecvQueue, &myobja);
myOutMsgobj.join();
myInMsgobj.join();
system("pause");
return 0;
}
4.1. 方法一:使用move转移
- my_unique_lock1拥有my_mutex1的所有权,my_unique_lock1可以把自己对my_mutex1的所有权转移,但是不能复制。
- unique_lock my_unique_lock12(std::move(my_unique_lock1));
现在my_unique_lock12拥有my_mutex1的所有权。
4.2.方法二: 在函数中return一个临时变量,即可以实现转移
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <list>
#include <thread>
#include <mutex>
using namespace std;
class A
{
public:
std::unique_lock<std::mutex> ReturnUniqueLock()
{
std::unique_lock<std::mutex> temp_unique_lock(my_mutex1);
//从函数返回一个临时的unique_lock是可以的(移动构造函数)
//返回这种局部对象temp_unique_lock会导致系统生成临时的unique_lock对象
//并调用unique_lock的移动构造函数
return temp_unique_lock;
}
//把收到的消息(玩家命令)插入到一个队列的线程
void inMesgRecvQueue()
{
for (int i = 0; i < 100000; ++i)
{
cout << "inMesgRecvQueue执行,插入一个元素" << i << endl;
//其他处理...
//std::unique_lock<std::mutex> my_unique_lock1(my_mutex1);//所有权概念
std::unique_lock<std::mutex> my_unique_lock2(my_mutex2);
//std::unique_lock<std::mutex> my_unique_lock12(my_unique_lock1);//复制是非法的
//移动语义,现在相当于my_unique_lock12和my_mutex1绑到一起了
//现在my_unique_lock1指向空,my_unique_lock12指向了my_mutex1
//std::unique_lock<std::mutex> my_unique_lock12(std::move(my_unique_lock1));
std::unique_lock<std::mutex> my_unique_lock13 = ReturnUniqueLock();
//移动语义,现在相当于my_unique_lock22和my_mutex2绑到一起了
//现在my_unique_lock2指向空,my_unique_lock22指向了my_mutex1
std::unique_lock<std::mutex> my_unique_lock22(std::move(my_unique_lock2));
//std::mutex *ptx1 = my_unique_lock1.release();
//std::mutex *ptx2 = my_unique_lock2.release();
list_msg.push_back(i);
//其他处理。。。
//ptx1->unlock();//自己负责my_mutex1的unlock
//ptx2->unlock();//自己负责my_mutex2的unlock
}
}
//把消息队列从容器中取出来的线程
void outMesgRecvQueue()
{
for (int i = 0; i < 100000; ++i)
{
if (!list_msg.empty())
{
int command = list_msg.front();
std::lock(my_mutex1, my_mutex2);//std::lock(my_mutex2, my_mutex2);
list_msg.pop_front();
my_mutex1.unlock();
my_mutex2.unlock();
}
else
{
cout << "消息队列为空" << endl;
}
}
cout << "outMesgRecvQueue end" << endl;
}
protected:
private:
std::list<int> list_msg;//专门用于代表玩家给咱们发送过来的命令
std::mutex my_mutex1;//创建了一个互斥量
std::mutex my_mutex2;//创建了一个互斥量
};
int main(int argc, char* argv[])
{
A myobja;
//第2个参数是引用,才能保证线程里面用的是同一个对象
std::thread myOutMsgobj(&A::outMesgRecvQueue, &myobja);
std::thread myInMsgobj(&A::inMesgRecvQueue, &myobja);
myOutMsgobj.join();
myInMsgobj.join();
system("pause");
return 0;
}