C++11的多线程并发编程(四)
继续记录锁的一些概念,眼瞅着疫情的拐点即将出现了。
- unique_lock
unique_lock这个是可以取代前一篇写的lock_guard,在第二个参数的为adopt_lock时与之前一样,表示unique_lock对象已经绑定了互斥量,提前lock互斥量,不用自己去unlock了,其实不建议搞这些花里胡哨的,lock和unlock对称使用貌似还清楚一点。
使用方法就是直接将lock_guard换成unique_lock
#include <iostream>
#include <thread>
#include <list>
#include <mutex>
using namespace std;
class A
{
public:
void inCommand()
{
for(int i = 0; i < 1000; i++)
{
lock(mylock1,mylock2);
lock_guard<mutex> myguard1(mylock1,adopt_lock);
lock_guard<mutex> myguard2(mylock2,adopt_lock);
// mylock.lock();
ticket.push_back(i);
cout << "a command is comming" << endl;
// mylock.unlock();
}
}
void outCommand()
{
for(int j = 0; j < 1000; j++)
{
lock(mylock1,mylock2);
unique_lock<mutex> myguard1(mylock1,adopt_lock);
unique_lock<mutex> myguard2(mylock2,adopt_lock);
// mylock.lock();
if(!ticket.empty())
{
int command = ticket.front();
ticket.pop_front();
cout << "command is :" << command << endl;
// mylock.unlock();
}
else
{
cout << "there is no people" << endl;
// mylock.unlock();
}
}
}
private:
list<int> ticket;
mutex mylock1;
mutex mylock2;
};
int main(int argc, char *argv[])
{
A a;
thread thread1(&A::inCommand, &a);
thread thread2(&A::outCommand, &a);
thread1.join();
thread2.join();
cout << "the main thread is end;" << endl;
return 0;
}
完全替换那要他有何用,存在即合理,设想一下,线程一拿到锁后要执行好长一段时间,线程二在等这个锁,难道他就这么一直等下去么,所以unique_lock的作用就体现出来,
try_to_lock参数,表示尝试去锁,如果没有锁定成功那么就可以去执行别的程序,并不会一直处于等待状态。
代码的写法如图所示:
unique_lock<mutex> myunique(mymutex, try_to_lock);
if(myunique.own_lock())
{
//获得了锁的权利
ticket.push_back(i);
//其他处理代码
}
else
{
//没拿到锁
cout << "消息收集函数在执行,却没有获得锁的权利执行与共享数据无关的程序"<< i << endl;
}
defer_lock参数,这个参数就是表示初始化了一个没有加锁的mutex,需要自己加锁,互斥量的解锁,到生命周期结束后自动结束。或者自己中途解锁也行。
2 成员函数release();
返回指向mutex指针,并解除对象与mutex的绑定,并通过指针进行调用解锁函数。
使用方法如图所示:
unique_lock<mutex> myunique(mymutex, try_to_lock);
//定义一个该类型指针
mutex *ptx = myunique.release();
ticket.push_back(i);
ptx->unlock();
或者通过移动语义move换个对象绑定
例如:
unique_lock<mutex> myunique(mymutex);
unique_lock<mutex> myunique2(move(myunique));
//定义一个指针
mutex *ptx = myunique2.release();
ticket.push_back(i);
ptx->unlock();
3.锁的粒度
这个是一个概念,锁住的代码少,那么锁的粒度就细,执行效率就越高
锁住的代码多,那么锁的粒度就粗,执行效率就越低,根据情况选择适合的粒度,当然了,这概念我也只是听到,没有实际的体验,先记下再说。
- 单例模式
这里顺便记录一下单例模式,之前一直模模糊糊不太懂,面试基本这个问题回答不上来。
单例模式:在整个任务中,有一些特殊的类,在程序里只能创建一个对象,
先放上代码:
```cpp
#include<iostream>
using namespace std;
class myClass
{
private:
myClass(){};
private:
static myClass *myPtr;
public:
static myClass *getInstance()
{
if(myPtr == NULL)
{
myPtr = new myClass();
}
return myPtr;
}
void myPrint()
{
cout << "hello comedy" << endl;
}
};
myClass *myClass::myPtr = NULL;
int main(int argv, char *argc[])
{
myClass *myptr1 = myClass::getInstance();
myClass *myptr2 = myClass::getInstance();
myptr1->myPrint();
myptr2->myPrint();
cout << " main thread end" << endl;
return 0;
}
运行结果如图所示:
构造函数的私有化,防止新建多个对象,指针所指向的对象唯一,并且静态表示不属于任何一个对象,属于类。此时代码的myptr1和myptr2所指向的地址是一个地址。
但这里你会发现两个问题,
一:new和delete是成对出现的,这个程序就不完美。
二:如果是两个线程进行new 对象,那么会出现线程一未完成new对象,进行到一半,而时间片转到线程二时,此时他又可以new一个,因为线程一未完全结束new对象,这样的话程序就可以产生两个new对象了,不符合单例模式的要求,因此借鉴案例分别引入
类中类,创建对象,然后推出程序的时候自动执行析构函数,函数中添加delete指针和互斥量的方法,线程进行加锁的方式进行互斥访问。
方法如图所示:
#include<iostream>
#include<mutex>
#include<thread>
using namespace std;
mutex mymutex;
class myClass
{
private:
myClass(){};
private:
static myClass *myPtr;
public:
static myClass *getInstance()
{
if(myPtr == NULL)
{
unique_lock<mutex> mylock(mymutex);
if(myPtr == NULL)
{
myPtr = new myClass();
static delClass mydelclass;
}
}
return myPtr;
}
class delClass
{
public:
~delClass()
{
if(myPtr != NULL)
{
delete myPtr;
cout << "delete myPtr" << endl;
}
}
};
void myPrint()
{
cout << "hello comedy" << endl;
}
};
myClass *myClass::myPtr = NULL;
void myFunc()
{
myClass *myptr1 = myClass::getInstance();
myptr1->myPrint();
cout << "hello yan" << endl;
}
int main(int argv, char *argc[])
{
thread t1(myFunc);
thread t2(myFunc);
t1.join();
t2.join();
cout << " main thread end" << endl;
return 0;
}
运行结果显示,正确无异常,且在程序退出后显示delete指针。
- call_once
后来了解到,c++11提供了一个函数call_once();可以代替这个只执行一次的new对象这个操作,以及增加参数互斥标志,就是全给你搞好了。
#include<iostream>
#include<mutex>
#include<thread>
using namespace std;
mutex mymutex;
once_flag myFlag;
class myClass
{
private:
myClass(){};
private:
static myClass *myPtr;
public:
static void singleCreate()
{
myPtr = new myClass();
static delClass mydelclass;
}
static myClass *getInstance()
{
call_once(myFlag, singleCreate);
// if(myPtr == NULL)
// {
// unique_lock<mutex> mylock(mymutex);
// if(myPtr == NULL)
// {
// myPtr = new myClass();
// static delClass mydelclass;
// }
// }
return myPtr;
}
class delClass
{
public:
~delClass()
{
delete myPtr;
cout << "delete myPtr" << endl;
}
};
void myPrint()
{
cout << "hello comedy" << endl;
}
};
myClass *myClass::myPtr = NULL;
void myFunc()
{
myClass *myptr1 = myClass::getInstance();
myptr1->myPrint();
cout << "hello yan" << endl;
}
int main(int argv, char *argc[])
{
thread t1(myFunc);
thread t2(myFunc);
t1.join();
t2.join();
cout << " main thread end" << endl;
return 0;
}
可以看到,结果与上述代码一样,可以单换。
留一个问题算了,getInstance为啥是指针返回,不是引用返回和值返回