c++ 11 多线程
主要参考https://www.bilibili.com/video/BV1Yb411L7ak?p=2
并发、进程、线程的基本概念和综述
并发，线程，进程要求必须掌握
1.1）并发
两个或者更多的任务（独立的活动）同时发生（进行），一个程序同时执行多个独立的任务
计算机，单核cpu（中央处理器）：某一个时刻能执行一个任务（进程）：由操作系统调度，每秒钟进行多次所谓的“任务切换，这是并发的假象（不是真正的并发）；这种切换上下文切换）是要有时间开销的，比如操作系统要保存你切换时的各种状态，执行进度等信息，都需要时间，一会切换回来的时候要复原这些信息。
硬件发展，出现了多处理器计算机：用于服务器和高性能计算领域。
在一块芯片上有多核（双核，4核，8核，10核
/能够实现真正的并行执行多个任务（硬件并发）
//使用并发的原因：主要就是同时可以干多个事，提高性能；
我的电脑上现在就有176个进程，但是显然没有176个核。
所以需要切换。
（1.2）可执行程序
磁盘上的一个文件， windows下，一个扩展名为。exe的。linux，1s-1a， rwxrwxrwx（x执行权限）；
（1.3）进程：大家已经知道了可执行程序是能够运行。
/ windows下，双击一个可执行程序来运行。linux下，/文件名。
进程，就是一个可执行程序运行起来了，就叫创建了一个进程
进程，就是运行起来了的可执行程序；
（1.4）线程
a）每个进程（执行起来的可执行程序），都有一个主线程，这个主线程是唯一的，也就是一个进程中只能有一个主线程。
b）当你执行一个执行程序，产生了一个进程后，这个主线程就随着这个进程黑默的启动起来了
这个程序的时候，实际上是进程的主线程来执行（调用）这个main函数中的代码
主线程与进程唇齿相依，有你必然有我，有我必然有你，没有我必然没有你
线程：用来执行代码的
/线程这个东西理解成一条代码的执行通路（道路）
除了主线程之外，我们可以通过自己写代码来创建其他线程，其他线程走的是别的道路，甚至去不同的地方
我每创建一个新线程，我就可以在同一个时刻，多做不同的事（多走一条不同的代码执行路径）
多线程（并发
线程并不是越多越好，每个线程，都需要一个独立的堆栈空间（1M），线程之间的切换要保存很多中间状态，切换会耗费本该属于程序运行的时间
多线程函数
程序运行起来，生成一个进程，该进程所属的主线程开始自动运行；当主线程从main（）函数返回，则整个进程执行完毕
主线程从main（）开始执行，那么我们自己创建的线程，也需要从一个函数开始运行（初始函数），一旦这个函数运行完毕，线程也结束运行
整个进程是否执行完毕的标志是：主线程是否执行完，如果主线程执行完毕了，就代表整个进程执行完毕了，此时如果其他子线程还没有执行完，也会被强行终止【此条有例外，以后会解释】
创建一个线程：
包含头文件thread
写初始函数
在main中创建thread
必须要明白：有两个线程在跑，相当于整个程序中有两条线在同时走，即使一条被阻塞，另一条也能运行
sublime+mingw出问题：
https://blog.csdn.net/qq_34719188/article/details/84193649
#include <iostream>
#include <thread>
using namespace std;
void myPrint()
{
cout << "myPrint start" << endl;
//-------------
//-------------
cout << "myPrint end" << endl;
return;
}
int main()
{
cout<<"main"<<endl;
thread p(myPrint);
p.join();
cout << "Hello World!" << endl;
return 0;
}
#include <iostream>
#include <thread>
using namespace std;
void myPrint()
{
cout << "myPrint start" << endl;
//-------------
//-------------
cout << "myPrint end" << endl;
return;
}
int main()
{
cout<<"main"<<endl;
thread p(myPrint);
// p.join();
cout << "Hello World!" << endl;
return 0;
}
没有join的阻塞，顺序就乱了，也不是正常的结束。
这是因为主线程main执行完了，但是线程myPrint还未执行完。最后虽然myPrint也执行结束了，但是那是因为发生了异常
#include <iostream>
#include <thread>
using namespace std;
void myPrint()
{
cout << "myPrint start" << endl;
//-------------
//-------------
cout << "myPrint end" << endl;
cout<<"1"<<endl;
cout<<"2"<<endl;
cout<<"3"<<endl;
return;
}
int main()
{
cout<<"main"<<endl;
thread p(myPrint);
// p.join();
p.detach();
cout << "Hello World!" << endl;
return 0;
}
我们发现子线程似乎没有运行。
同样的代码再执行一次：
#include <iostream>
#include <thread>
using namespace std;
void myPrint()
{
cout << "myPrint start" << endl;
//-------------
//-------------
cout << "myPrint end" << endl;
cout<<"1"<<endl;
cout<<"2"<<endl;
cout<<"3"<<endl;
return;
}
int main()
{
cout<<"main"<<endl;
thread p(myPrint);
// p.join();
cout << "Hello World!" << endl;
p.detach();
return 0;
}
只有这种结果。
#include <iostream>
#include <thread>
using namespace std;
void myPrint()
{
cout << "myPrint start" << endl;
//-------------
//-------------
cout << "myPrint end" << endl;
cout<<"1"<<endl;
cout<<"2"<<endl;
cout<<"3"<<endl;
return;
}
int main()
{
thread p(myPrint);
p.detach();
cout<<"main"<<endl;
// p.join();
cout << "Hello World!" << endl;
return 0;
}
#include <iostream>
#include <thread>
using namespace std;
void myPrint()
{
cout << "myPrint start" << endl;
//-------------
//-------------
cout << "myPrint end" << endl;
cout<<"1"<<endl;
cout<<"2"<<endl;
cout<<"3"<<endl;
cout<<"4"<<endl;
cout<<"5"<<endl;
return;
}
int main()
{
thread p(myPrint);
p.detach();
cout<<"main"<<endl;
// p.join();
cout << "Hello World!" << endl;
return 0;
}
这个结果其实也不确定，这一种是5没打印出来。这是因为主线程的退出导致进程的退出，这中间有段时间，而进程一旦退出，这个打印的窗口就没了，其实子线程也打印了，但是这个5我们看不到了而已。
#include <iostream>
#include <thread>
using namespace std;
void myPrint()
{
cout << "myPrint start" << endl;
//-------------
//-------------
cout << "myPrint end" << endl;
cout<<"1"<<endl;
cout<<"2"<<endl;
cout<<"3"<<endl;
cout<<"4"<<endl;
cout<<"5"<<endl;
return;
}
int main()
{
thread p(myPrint);
p.detach();
cout<<"main"<<endl;
p.join();
// p.join();
cout << "Hello World!" << endl;
return 0;
}
先detach后join会有异常。反之一样。不过异常发生的地方不同，先detach再join应该是执行到主线程的p.join()出错的，而先join()在detach是在阻塞执行完myPrint后，转而执行p.detach()时报错的。
joinable()判断子线程是否可以join和detach。
线程类参数是一个可调用对象。
一组可执行的语句称为可调用对象，c++中的可调用对象可以是函数、函数指针、lambda表达式、bind创建的对象或者重载了函数调用运算符的类对象。
①创建一个类，并编写圆括号重载函数，初始化一个该类的对象，把该对象作为线程入口地址：
#include <iostream>
#include <thread>
using namespace std;
class Ta
{
int &n;
public:
Ta(int &m):n(m){cout<<"构造函数"<<endl;}
Ta( const Ta & ta):n(ta.n)
{cout<<"复制构造函数"<<endl;
}
~Ta()
{
cout<<"析构函数"<<endl;
}
void operator()()
{
cout << "我的线程开始运行" << endl;
//-------------
//-------------
cout << "我的线程运行完毕" << endl;
}
};
int main(int argc, char const *argv[])
{
//main函数里的：
cout<<"mainstart"<<endl;
int a=1;
Ta ta(a);
cout<<"进入子线程"<<endl;
thread myThread(ta);
myThread.join();
cout<<"mainend"<<endl;
return 0;
}
这个ta在子线程里复制了两次我没想到。
这个程序有问题，在于类里有引用。如果用了detach，那么主线程可能结束了，a的资源被释放而子线程还有a的引用，这会导致问题。
类函数
#include <iostream>
#include <thread>
using namespace std;
class Data_
{
public:
Data_(const Data_& d)
{
cout<<"复制构造"<<endl;
}
Data_()
{
cout<<"构造"<<endl;
}
~Data_()
{
cout<<"析构"<<endl;
}
void operator()()
{
cout<<"调用"<<endl;
}
void GetMsg(){
cout<<"msg"<<endl;
}
void SaveMsh(){
cout<<"save"<<endl;
}
};
//main函数里
int main(int argc, char const *argv[])
{
//main函数里的：
cout<<"mainstart"<<endl;
Data_ s;
//第一个&意思是取址，第二个&意思是引用，相当于std::ref(s)
//thread oneobj(&Data_::SaveMsh,s)传值也是可以的
//在其他的构造函数中&obj是不会代表引用的，会被当成取地址
thread oneobj(&Data_::SaveMsh,&s);
thread twoobj(&Data_::GetMsg,&s);
oneobj.join();
twoobj.join();
cout<<"mainend"<<endl;
return 0;
}
如果传值：
两个子线程的执行互不干扰。
完成的先后取决于启动线程的先后。
这个复制构造函数按照视频里老师讲的应该是出现一次，不过他用的是MSVC，我是G++，不同的编译器处理可能不同。
线程传参
#include <iostream>
#include <thread>
using namespace std;
void myPrint(const int &i, char* pmybuf)
{
//如果线程从主线程detach了
//i不是mvar真正的引用，实际上值传递，即使主线程运行完毕了，子线程用i仍然是安全的，但仍不推荐传递引用
//推荐改为const int i
cout << i << endl<<&i<<endl;
//pmybuf还是指向原来的字符串，所以这么写是不安全的
cout << pmybuf << endl<<&pmybuf<<endl;
}
int main()
{
int mvar = 1;
int& mvary = mvar;
cout<<&mvar<<endl<<&mvary<<endl;
char mybuf[] = "this is a test";
cout<<"mybuf"<<&mybuf<<endl;
thread myThread(myPrint, mvar, mybuf);//第一个参数是函数名，后两个参数是函数的参数
myThread.join();
//myThread.detach();
cout << "Hello World!" << endl;
}
看来g++的处理很谨慎，无论是引用传递还是指针传递，都会复制一份。
这样是很好的，因为即便是detach了，也不会出现问题。
#include <iostream>
#include <thread>
using namespace std;
class A
{
public:
int a;
A(const A &b):a(b.a)
{
cout<<"复制构造"<<endl;
}
A( int n):a(n)
{
cout<<"构造"<<endl;
}
~A()
{
cout<<"析构"<<endl;
}
};
void myprint(const A & a)
{
cout<<"start";
cout<<&a<<endl;
}
int main()
{
int mvar = 1;
thread p(myprint,mvar);
p.join();
cout << "Hello World!" << endl;
}
如果有隐式的类型转换。
如果用了detach：
可能这个隐式的转换会来不及，这个myvar的空间就释放了。
显式的好一些。
总结
如果传递int这种简单类型，推荐使用值传递，不要用引用
如果传递类对象，避免使用隐式类型转换，全部都是创建线程这一行就创建出临时对象，然后在函数参数里，用引用来接，否则还会创建出一个对象
终极结论：建议不使用detach
#include <iostream>
#include <thread>
using namespace std;
class A
{
public:
int a;
A(const A &b):a(b.a)
{
cout<<"复制构造"<<endl;
}
A( int n):a(n)
{
cout<<"构造"<<endl;
}
~A()
{
cout<<"析构"<<endl;
}
};
void myprint(const A a)
{
cout<<"start";
cout<<&a<<endl;
}
int main()
{
int mvar = 1;
thread p(myprint,A(mvar));
p.join();
cout << "Hello World!" << endl;
}
函数不用引用接受的话，g++要三次复制构造，这…
#include <iostream>
#include <thread>
using namespace std;
class A
{
public:
int a;
A(const A &b):a(b.a)
{
cout<<"复制构造"<<endl;
cout<<this<<" "<<this_thread::get_id()<<endl;
}
A( int n):a(n)
{
cout<<"构造"<<endl;
cout<<this<<" "<<this_thread::get_id()<<endl;
}
~A()
{
cout<<"析构"<<endl;
cout<<this<<" "<<this_thread::get_id()<<endl;
}
};
void myprint(const A a)
{
cout<<"start";
cout<<&a<<endl;
cout<<"子线程"<<this_thread::get_id()<<endl;
}
int main()
{
int mvar = 1;
cout<<"主线程"<<this_thread::get_id()<<endl;
thread p(myprint,A(mvar));
p.join();
cout << "Hello World!" << endl;
}
this_thread::get_id()可以得到线程的id。
看到前两次复制构造都是在主线程构造的。第三次是在子线程中构造的。
比较奇怪的是0xfc18c8的析构是子线程里的。在myprint里的A对象的this是0x28dfdlc。函数接受的是引用的时候：
0x6a18c8是在主线程构造，在子线程析构的。
隐式复制：
构造和析构在子线程里，比较危险。
#include <iostream>
#include <thread>
using namespace std;
class A
{
public:
mutable int a;
A(const A &b):a(b.a)
{
cout<<"复制构造"<<endl;
cout<<this<<" "<<this_thread::get_id()<<endl;
}
A( int n):a(n)
{
cout<<"构造"<<endl;
cout<<this<<" "<<this_thread::get_id()<<endl;
}
~A()
{
cout<<"析构"<<endl;
cout<<this<<" "<<this_thread::get_id()<<endl;
}
};
void myprint( const A &a)
{
cout<<"start";
cout<<&a<<endl;
a.a=199;
cout<<a.a<<endl;
cout<<"子线程"<<this_thread::get_id()<<endl;
}
int main()
{
int mvar = 1;
A a(mvar);
cout<<"主线程"<<this_thread::get_id()<<endl;
thread p(myprint,a);
p.join();
cout<<a.a<<endl;
cout << "Hello World!" << endl;
}
这样显然无法改变主线程a对象的属性。
如果想改变，需要用std::ref
#include <iostream>
#include <thread>
using namespace std;
class A
{
public:
mutable int a;
A(const A &b):a(b.a)
{
cout<<"复制构造"<<endl;
cout<<this<<" "<<this_thread::get_id()<<endl;
}
A( int n):a(n)
{
cout<<"构造"<<endl;
cout<<this<<" "<<this_thread::get_id()<<endl;
}
~A()
{
cout<<"析构"<<endl;
cout<<this<<" "<<this_thread::get_id()<<endl;
}
};
void myprint( A &a)
{
cout<<"start";
cout<<&a<<endl;
a.a=199;
cout<<a.a<<endl;
cout<<"子线程"<<this_thread::get_id()<<endl;
}
int main()
{
int mvar = 1;
A a(mvar);
cout<<"主线程"<<this_thread::get_id()<<endl;
thread p(myprint,ref(a));
p.join();
cout<<a.a<<endl;
cout << "Hello World!" << endl;
}
智能指针
#include <iostream>
#include <thread>
#include <memory>
using namespace std;
void myPrint(int* ptn)
{
cout<<ptn<<endl;
cout << "thread = " << std::this_thread::get_id() << endl;
}
int main()
{
// unique_ptr<int> up(new int(10));
int *p,a=1;
p=&a;
cout<<p<<endl;
//独占式指针只能通过std::move()才可以传递给另一个指针
//传递后up就指向空，新的ptn指向原来的内存
//所以这时就不能用detach了，因为如果主线程先执行完，ptn指向的对象就被释放了
thread myThread(myPrint,p);
myThread.join();
//myThread.detach();
return 0;
}
传递指针都有风险，额，其实上面的字符串应该也是。
#include <iostream>
#include <thread>
#include <memory>
using namespace std;
void myPrint(unique_ptr<int> ptn)
{
cout << "thread = " << std::this_thread::get_id() << endl;
}
int main()
{
unique_ptr<int> up(new int(10));
//独占式指针只能通过std::move()才可以传递给另一个指针
//传递后up就指向空，新的ptn指向原来的内存
//所以这时就不能用detach了，因为如果主线程先执行完，ptn指向的对象就被释放了
thread myThread(myPrint, std::move(up));
myThread.join();
//myThread.detach();
return 0;
}
智能指针也一样。
数据保护
#include <iostream>
#include <thread>
#include <vector>
using namespace std;
void TextThread(int n)
{
cout << "我是线程" << this_thread::get_id() << endl;
/* … */
cout<<n<<endl;
cout << "线程" << this_thread::get_id() << "执行结束" << endl;
}
//main函数里 vector threadagg;
int main(int argc, char const *argv[])
{
vector<thread> threadagg;
for (int i = 0; i < 10; ++i)
{
threadagg.push_back(thread(TextThread,i));
}
for (int i = 0; i < 10; ++i)
{
threadagg[i].join();
}
return 0;
}
有可能线程的执行顺序和启动顺序不同，这和系统调度有关。
#include <iostream>
#include <thread>
#include <list>
using namespace std;
class A
{
private:
list<int> q;
public:
A()
{cout<<this<<endl<<"构造函数"<<endl;}
~A(){cout<<this<<endl<<"析构函数"<<endl;}
void wq()
{
for(int i=0;i<100000;i++)
{
q.push_front(i);
cout<<"写入"<<i<<endl;
}
}
void rq()
{
for(int i=0;i<100000;i++)
{
if(q.size())
{
cout<<"读取"<<q.front();
q.pop_front();
}
else
{
cout<<"等待读取"<<endl;
}
}
cout<<"读取结束"<<endl;
}
};
//main函数里 vector threadagg;
int main(int argc, char const *argv[])
{
A a;
thread w(&A::wq,&a);
thread r(&A::rq,&a);
w.join();
r.join();
return 0;
}
这种既写又读的应该会出问题，然而我在g++上居然没有出错。
#include <iostream>
#include <thread>
#include <list>
using namespace std;
class A
{
private:
int q;
public:
A()
{cout<<this<<endl<<"构造函数"<<endl;}
~A(){cout<<this<<endl<<"析构函数"<<endl;}
void wq()
{
for(int i=0;i<100000;i++)
{
q=i;
cout<<"写入"<<i<<endl;
}
}
void rq()
{
for(int i=0;i<100000;i++)
{
cout<<q<<endl;
}
cout<<"读取结束"<<endl;
}
};
//main函数里 vector threadagg;
int main(int argc, char const *argv[])
{
A a;
thread w(&A::wq,&a);
thread r(&A::rq,&a);
w.join();
r.join();
return 0;
}
也不i报错，挺奇怪的，但是这样肯定是有问题的，所以需要线程锁。
互斥量
一、互斥量（mutex）的基本概念
互斥量就是个类对象，可以理解为一把锁，多个线程尝试用lock()成员函数来加锁，只有一个线程能锁定成功，如果没有锁成功，那么流程将卡在lock()这里不断尝试去锁定。
互斥量使用要小心，保护数据不多也不少，少了达不到效果，多了影响效率。
二、互斥量的用法
包含#include 头文件
2.1 lock()，unlock()
步骤：1.lock()，2.操作共享数据，3.unlock()。
lock()和unlock()要成对使用
#include <iostream>
#include <thread>
#include <list>
#include <mutex>
using namespace std;
class A
{
private:
list<int> q;
mutex my_muetx;
public:
A()
{cout<<this<<endl<<"构造函数"<<endl;}
~A(){cout<<this<<endl<<"析构函数"<<endl;}
void wq()
{
for(int i=0;i<100000;i++)
{
my_muetx.lock();
q.push_front(i);
my_muetx.unlock();
cout<<"写入"<<i<<endl;
}
}
void rq()
{
for(int i=0;i<100000;i++)
{
my_muetx.lock();
if(q.size())
{
cout<<"读取"<<q.front();
q.pop_front();
my_muetx.unlock();
}
else
{
my_muetx.unlock();
cout<<"等待读取"<<endl;
}
}
cout<<"读取结束"<<endl;
}
};
//main函数里 vector threadagg;
int main(int argc, char const *argv[])
{
A a;
thread w(&A::wq,&a);
thread r(&A::rq,&a);
w.join();
r.join();
return 0;
}
尤其注意if条件判断的unlock()配对。
2.2 lock_guard类模板
lock_guard sbguard(myMutex);取代lock()和unlock()
lock_guard构造函数执行了mutex::lock();在作用域结束时，调用析构函数，执行mutex::unlock()
代码：
#include <iostream>
#include <thread>
#include <list>
#include <mutex>
using namespace std;
class A
{
private:
list<int> q;
mutex my_muetx;
public:
A()
{cout<<this<<endl<<"构造函数"<<endl;}
~A(){cout<<this<<endl<<"析构函数"<<endl;}
void wq()
{
for(int i=0;i<100000;i++)
{
// my_muetx.lock();
lock_guard<mutex> lg(my_muetx);
q.push_front(i);
// my_muetx.unlock();
cout<<"写入"<<i<<endl;
}
}
void rq()
{
for(int i=0;i<100000;i++)
{
lock_guard<mutex> lg(my_muetx);
if(q.size())
{
cout<<"读取"<<q.front();
q.pop_front();
// my_muetx.unlock();
}
else
{
// my_muetx.unlock();
cout<<"等待读取"<<endl;
}
}
cout<<"读取结束"<<endl;
}
};
//main函数里 vector threadagg;
int main(int argc, char const *argv[])
{
A a;
thread w(&A::wq,&a);
thread r(&A::rq,&a);
w.join();
r.join();
return 0;
}
三、死锁
3.1 死锁演示
死锁至少有两个互斥量mutex1，mutex2。
a.线程A执行时，这个线程先锁mutex1，并且锁成功了，然后去锁mutex2的时候，出现了上下文切换。
b.线程B执行，这个线程先锁mutex2，因为mutex2没有被锁，即mutex2可以被锁成功，然后线程B要去锁mutex1.
c.此时，死锁产生了，A锁着mutex1，需要锁mutex2，B锁着mutex2，需要锁mutex1，两个线程没办法继续运行下去。。。
#include <iostream>
#include <thread>
#include <list>
#include <mutex>
using namespace std;
class A
{
private:
list<int> q;
mutex my_muetx1,my_muetx2;
public:
A()
{cout<<this<<endl<<"构造函数"<<endl;}
~A(){cout<<this<<endl<<"析构函数"<<endl;}
void wq()
{
for(int i=0;i<100000;i++)
{
// my_muetx.lock();
lock_guard<mutex> lg(my_muetx1);
lock_guard<mutex> lg2(my_muetx2);
q.push_front(i);
// my_muetx.unlock();
cout<<"写入"<<i<<endl;
}
}
void rq()
{
for(int i=0;i<100000;i++)
{
lock_guard<mutex> lg(my_muetx2);
lock_guard<mutex> lg2(my_muetx1);
if(q.size())
{
cout<<"读取"<<q.front();
q.pop_front();
// my_muetx.unlock();
}
else
{
// my_muetx.unlock();
cout<<"等待读取"<<endl;
}
}
cout<<"读取结束"<<endl;
}
};
//main函数里 vector threadagg;
int main(int argc, char const *argv[])
{
A a;
thread w(&A::wq,&a);
thread r(&A::rq,&a);
w.join();
r.join();
return 0;
}
这就发生了死锁。
3.2 死锁的一般解决方案：
只要保证多个互斥量上锁的顺序一样就不会造成死锁。
3.3 std::lock()函数模板
std::lock(mutex1,mutex2……); 一次锁定多个互斥量（一般这种情况很少），用于处理多个互斥量。
如果互斥量中一个没锁住，它就等着，等所有互斥量都锁住，才能继续执行。如果有一个没锁住，就会把已经锁住的释放掉（要么互斥量都锁住，要么都没锁住，防止死锁）
#include <iostream>
#include <thread>
#include <list>
#include <mutex>
using namespace std;
class A
{
private:
list<int> q;
mutex my_muetx1,my_muetx2;
public:
A()
{cout<<this<<endl<<"构造函数"<<endl;}
~A(){cout<<this<<endl<<"析构函数"<<endl;}
void wq()
{
for(int i=0;i<100000;i++)
{
// // my_muetx.lock();
lock(my_muetx1,my_muetx2);
q.push_front(i);
my_muetx1.unlock();
my_muetx2.unlock();
cout<<"写入"<<i<<endl;
}
}
void rq()
{
for(int i=0;i<100000;i++)
{
// lock_guard<mutex> lg(my_muetx2);
// lock_guard<mutex> lg2(my_muetx1);
lock(my_muetx1,my_muetx2);
if(q.size())
{
cout<<"读取"<<q.front();
q.pop_front();
// my_muetx.unlock();
my_muetx1.unlock();
my_muetx2.unlock();
}
else
{
// my_muetx.unlock();
my_muetx1.unlock();
my_muetx2.unlock();
cout<<"等待读取"<<endl;
}
}
cout<<"读取结束"<<endl;
}
};
//main函数里 vector threadagg;
int main(int argc, char const *argv[])
{
A a;
thread w(&A::wq,&a);
thread r(&A::rq,&a);
w.join();
r.join();
return 0;
}
还可以:
3.4 std::lock_guard的std::adopt_lock参数
std::lock_guardstd::mutex my_guard(my_mutex,std::adopt_lock);
加入adopt_lock后，在调用lock_guard的构造函数时，不再进行lock();
adopt_guard为结构体对象，起一个标记作用，表示这个互斥量已经lock()，不需要在lock()。
#include <iostream>
#include <thread>
#include <list>
#include <mutex>
using namespace std;
class A
{
private:
list<int> q;
mutex my_muetx1,my_muetx2;
public:
A()
{cout<<this<<endl<<"构造函数"<<endl;}
~A(){cout<<this<<endl<<"析构函数"<<endl;}
void wq()
{
for(int i=0;i<100000;i++)
{
// // my_muetx.lock();
lock(my_muetx1,my_muetx2);
lock_guard<mutex> lg(my_muetx1,adopt_lock);
lock_guard<mutex> lg1(my_muetx2,adopt_lock);
q.push_front(i);
// my_muetx1.unlock();
// my_muetx2.unlock();
cout<<"写入"<<i<<endl;
}
}
void rq()
{
for(int i=0;i<100000;i++)
{
// lock_guard<mutex> lg(my_muetx2);
// lock_guard<mutex> lg2(my_muetx1);
lock(my_muetx1,my_muetx2);
lock_guard<mutex> lg(my_muetx1,adopt_lock);
lock_guard<mutex> lg1(my_muetx2,adopt_lock);
if(q.size())
{
cout<<"读取"<<q.front();
q.pop_front();
// my_muetx.unlock();
// my_muetx1.unlock();
// my_muetx2.unlock();
}
else
{
// my_muetx.unlock();
// my_muetx1.unlock();
// my_muetx2.unlock();
cout<<"等待读取"<<endl;
}
}
cout<<"读取结束"<<endl;
}
};
//main函数里 vector threadagg;
int main(int argc, char const *argv[])
{
A a;
thread w(&A::wq,&a);
thread r(&A::rq,&a);
w.join();
r.join();
return 0;
}
2.unique_lock的第二个参数
2.1 std::adopt_lock：
表示这个互斥量已经被lock()，即不需要在构造函数中lock这个互斥量了。
前提：必须提前lock
lock_guard中也可以用这个参数
2.2 std::try_to_lock：
尝试用mutx的lock()去锁定这个mutex，但如果没有锁定成功，会立即返回，不会阻塞在那里；
使用try_to_lock的原因是防止其他的线程锁定mutex太长时间，导致本线程一直阻塞在lock这个地方
前提：不能提前lock();
owns_locks()方法判断是否拿到锁，如拿到返回true
#include <iostream>
#include <thread>
#include <list>
#include <mutex>
using namespace std;
class A
{
private:
list<int> q;
mutex my_muetx1,my_muetx2;
public:
A()
{cout<<this<<endl<<"构造函数"<<endl;}
~A(){cout<<this<<endl<<"析构函数"<<endl;}
void wq()
{
for(int i=0;i<100000;i++)
{
// // my_muetx.lock();
// lock(my_muetx1,my_muetx2);
lock_guard<mutex> lg(my_muetx1);
chrono::milliseconds dura(1);
this_thread::sleep_for(dura);
// lock_guard<mutex> lg1(my_muetx2,adopt_lock);
q.push_front(i);
// my_muetx1.unlock();
// my_muetx2.unlock();
cout<<"写入"<<i<<endl;
}
}
void rq()
{
for(int i=0;i<100000;i++)
{
// lock_guard<mutex> lg(my_muetx2);
// lock_guard<mutex> lg2(my_muetx1);
unique_lock<mutex> ml(my_muetx1,try_to_lock);
// lock(my_muetx1,my_muetx2);
// lock_guard<mutex> lg(my_muetx1,adopt_lock);
// lock_guard<mutex> lg1(my_muetx2,adopt_lock);
if (ml.owns_lock())
{
cout<<"get_lock"<<endl;
if(q.size())
{
cout<<"读取"<<q.front();
q.pop_front();
// my_muetx.unlock();
// my_muetx1.unlock();
// my_muetx2.unlock();
}
else
{
// my_muetx.unlock();
// my_muetx1.unlock();
// my_muetx2.unlock();
cout<<"等待读取"<<endl;
}
}
else cout<<"未拿到锁"<<endl;
}
cout<<"读取结束"<<endl;
}
};
//main函数里 vector threadagg;
int main(int argc, char const *argv[])
{
A a;
thread w(&A::wq,&a);
thread r(&A::rq,&a);
w.join();
r.join();
return 0;
}
2.3 std::defer_lock：
如果没有第二个参数就对mutex进行加锁，加上defer_lock是始化了一个没有加锁的mutex
不给它加锁的目的是以后可以调用unique_lock的一些方法
前提：不能提前lock
lock()，unlock()和try_lock()都要和defer_lock一起使用，而release不需要。
#include <iostream>
#include <thread>
#include <list>
#include <mutex>
using namespace std;
class A
{
private:
list<int> q;
mutex my_muetx1,my_muetx2;
public:
A()
{cout<<this<<endl<<"构造函数"<<endl;}
~A(){cout<<this<<endl<<"析构函数"<<endl;}
void wq()
{
for(int i=0;i<100000;i++)
{
// // my_muetx.lock();
// lock(my_muetx1,my_muetx2);
lock_guard<mutex> lg(my_muetx1);
// chrono::milliseconds dura(1);
// this_thread::sleep_for(dura);
// lock_guard<mutex> lg1(my_muetx2,adopt_lock);
q.push_front(i);
// my_muetx1.unlock();
// my_muetx2.unlock();
cout<<"写入"<<i<<endl;
}
}
void rq()
{
for(int i=0;i<100000;i++)
{
// lock_guard<mutex> lg(my_muetx2);
// lock_guard<mutex> lg2(my_muetx1);
unique_lock<mutex> ml(my_muetx1,try_to_lock);
// lock(my_muetx1,my_muetx2);
// lock_guard<mutex> lg(my_muetx1,adopt_lock);
// lock_guard<mutex> lg1(my_muetx2,adopt_lock);
if (ml.owns_lock())
{
cout<<"get_lock"<<endl;
mutex *pt=ml.release();
if(q.size())
{
cout<<"读取"<<q.front();
q.pop_front();
// my_muetx.unlock();
// my_muetx1.unlock();
// my_muetx2.unlock();
pt->unlock();
}
else
{
// my_muetx.unlock();
// my_muetx1.unlock();
// my_muetx2.unlock();
cout<<"等待读取"<<endl;
pt->unlock();
}
}
else cout<<"未拿到锁"<<endl;
}
cout<<"读取结束"<<endl;
}
};
//main函数里 vector threadagg;
int main(int argc, char const *argv[])
{
A a;
thread w(&A::wq,&a);
thread r(&A::rq,&a);
w.join();
r.join();
return 0;
}
4.unique_lock所有权的传递
unique_lock myUniLock(myMutex);把myMutex和myUniLock绑定在了一起，也就是myUniLock拥有myMutex的所有权
- 使用move转移
myUniLock拥有myMutex的所有权，myUniLock可以把自己对myMutex的所有权转移，但是不能复制。
unique_lock myUniLock2(std::move(myUniLock));
现在myUniLock2拥有myMutex的所有权。
#include <iostream>
#include <thread>
#include <list>
#include <mutex>
using namespace std;
class A
{
private:
list<int> q;
mutex my_muetx1,my_muetx2;
public:
A()
{cout<<this<<endl<<"构造函数"<<endl;}
~A(){cout<<this<<endl<<"析构函数"<<endl;}
void wq()
{
for(int i=0;i<100000;i++)
{
// // my_muetx.lock();
// lock(my_muetx1,my_muetx2);
lock_guard<mutex> lg(my_muetx1);
// chrono::milliseconds dura(1);
// this_thread::sleep_for(dura);
// lock_guard<mutex> lg1(my_muetx2,adopt_lock);
q.push_front(i);
// my_muetx1.unlock();
// my_muetx2.unlock();
cout<<"写入"<<i<<endl;
}
}
void rq()
{
for(int i=0;i<100000;i++)
{
// lock_guard<mutex> lg(my_muetx2);
// lock_guard<mutex> lg2(my_muetx1);
unique_lock<mutex> ml(my_muetx1,try_to_lock);
unique_lock<mutex> sg(move(ml));
// lock(my_muetx1,my_muetx2);
// lock_guard<mutex> lg(my_muetx1,adopt_lock);
// lock_guard<mutex> lg1(my_muetx2,adopt_lock);
if (sg.owns_lock())
{
cout<<"get_lock"<<endl;
mutex *pt=sg.release();
if(q.size())
{
cout<<"读取"<<q.front();
q.pop_front();
// my_muetx.unlock();
// my_muetx1.unlock();
// my_muetx2.unlock();
pt->unlock();
}
else
{
// my_muetx.unlock();
// my_muetx1.unlock();
// my_muetx2.unlock();
cout<<"等待读取"<<endl;
pt->unlock();
}
}
else cout<<"未拿到锁"<<endl;
}
cout<<"读取结束"<<endl;
}
};
//main函数里 vector threadagg;
int main(int argc, char const *argv[])
{
A a;
thread w(&A::wq,&a);
thread r(&A::rq,&a);
w.join();
r.join();
return 0;
}
- 在函数中return一个临时变量，即可以实现转移
#include <iostream>
#include <thread>
#include <list>
#include <mutex>
using namespace std;
class A
{
private:
list<int> q;
mutex my_muetx1,my_muetx2;
public:
unique_lock<mutex> aFunction()
{
unique_lock<mutex> myUniLock(my_muetx1,try_to_lock);
//移动构造函数那里讲从函数返回一个局部的unique_lock对象是可以的
//返回这种局部对象会导致系统生成临时的unique_lock对象，并调用unique_lock的移动构造函数
return myUniLock;
}
A()
{cout<<this<<endl<<"构造函数"<<endl;}
~A(){cout<<this<<endl<<"析构函数"<<endl;}
void wq()
{
for(int i=0;i<100000;i++)
{
// // my_muetx.lock();
// lock(my_muetx1,my_muetx2);
lock_guard<mutex> lg(my_muetx1);
// chrono::milliseconds dura(1);
// this_thread::sleep_for(dura);
// lock_guard<mutex> lg1(my_muetx2,adopt_lock);
q.push_front(i);
// my_muetx1.unlock();
// my_muetx2.unlock();
cout<<"写入"<<i<<endl;
}
}
void rq()
{
for(int i=0;i<100000;i++)
{
// lock_guard<mutex> lg(my_muetx2);
// lock_guard<mutex> lg2(my_muetx1);
// unique_lock<mutex> ml(my_muetx1,try_to_lock);
unique_lock<mutex> sg=aFunction();
// lock(my_muetx1,my_muetx2);
// lock_guard<mutex> lg(my_muetx1,adopt_lock);
// lock_guard<mutex> lg1(my_muetx2,adopt_lock);
if (sg.owns_lock())
{
cout<<"get_lock"<<endl;
mutex *pt=sg.release();
if(q.size())
{
cout<<"读取"<<q.front();
q.pop_front();
// my_muetx.unlock();
// my_muetx1.unlock();
// my_muetx2.unlock();
pt->unlock();
}
else
{
// my_muetx.unlock();
// my_muetx1.unlock();
// my_muetx2.unlock();
cout<<"等待读取"<<endl;
pt->unlock();
}
}
else cout<<"未拿到锁"<<endl;
}
cout<<"读取结束"<<endl;
}
};
//main函数里 vector threadagg;
int main(int argc, char const *argv[])
{
A a;
thread w(&A::wq,&a);
thread r(&A::rq,&a);
w.join();
r.join();
return 0;
}
这里牵扯到了移动构造。
回顾左值和右值。
- 左值和右值
（1）两者区别：
①左值：能对表达式取地址、或具名对象/变量。一般指表达式结束后依然存在的持久对象。
②右值：不能对表达式取地址，或匿名对象。一般指表达式结束就不再存在的临时对象。
（2）右值的分类
①将亡值（xvalue，eXpiring value）：指生命期即将结束的值，一般是跟右值引用相关的表达式，这样表达式通常是将要被移动的对象，如返回类型为T&&的函数返回值（如std::move）、经类型转换为右值引用的对象（如static_cast<T&&>(obj)）、xvalue类对象的成员访问表达式也是一个xvalue（如Test().memberdata，注意Test()是个临时对象）
②纯右值（prvalue， PureRvalue）：按值返回的临时对象、运算表达式产生的临时变对象、原始字面量和lambda表达式等。
3）C++11中的表达式
①表达式是由运算符(operator)和运算对象(operand)构成的计算式。字面值和变量是最简单的表达式，函数的返回值也被认为是表达式。
②表达式是可求值的，对表达式求值将得到一个结果，这个结果有两个属性：类型和值类别，而表达式的值类别必属于左值、将亡值或纯右值三者之一。
③“左值”和“右值”是表达式结果的一种属性。通常用“左值”来指代左值表达式，用“右值”指代右值表达式。
参考https://blog.csdn.net/linuxheik/article/details/78929128
移动构造
C++ 11 标准中提供了一种新的构造方法–移动构造
C++11 之前，如果要将源对象的状态转移到目标对象只能通过复制。在某些情况下，我们有没有必要复制对象----只需要移动他们
移动语义：源对象资源的控制权全部交给目标对
什么时候用移动构造？
临时对象即将消亡，但里面的数据还是要用的，所以用移动构造
#include <iostream>
using namespace std;
class IntNum
{
public:
IntNum(int x =0): xpt(new int(x))//构造函数
{
cout <<"Calling constructor"<< endl;
}
IntNum( const IntNum & n):xpt( new int(*n.xpt))
{//复制构造函数
cout <<"Calling copy constructor. "<< endl;
}
~ IntNum()
{//析构函数
delete xpt;
cout<<"Destructing."<<endl;
}
int getInt()
{
return *xpt;
}
private:
int *xpt;
};
IntNum getNum()
{
IntNum a;
return a;
}
int main(int argc, char const *argv[])
{
cout<<getNum().getInt();
return 0;
}
移动构造：
#include <iostream>
using namespace std;
class IntNum
{
public:
IntNum(int x =0): xpt(new int(x))//构造函数
{
cout <<"Calling constructor"<< endl;
}
IntNum( const IntNum & n):xpt( new int(*n.xpt))
{//复制构造函数
cout <<"Calling copy constructor. "<< endl;
}
IntNum( IntNum &&n):xpt(n.xpt)
{
n.xpt=nullptr;
cout<<"move constructor"<<endl;
}
~ IntNum()
{//析构函数
delete xpt;
cout<<"Destructing."<<endl;
}
int getInt()
{
return *xpt;
}
private:
int *xpt;
};
IntNum getNum()
{
IntNum a;
return a;
}
int main(int argc, char const *argv[])
{
cout<<getNum().getInt();
return 0;
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
