C++编程笔记(多线程学习)
目录
一、线程创建
每个程序都有一个主线程，主线程的入口函数就是main函数，一般情况下，主线程结束，无论子线程是否执行完毕，子线程都将结束
#include <iostream>
#include <thread>
#include <string>
using std::cout;
using std::thread;
//线程入口函数,函数完毕，线程结束
void MyPrint() {
cout << "This is MyThread!\n";
cout << "MyThread is finish!\n";
}
int main() {
cout << "你好\n";
thread MyThread1(MyPrint);//创建子线程，接收可调用对象
cout<<"Main finish!\n";
return 0;
}
二、线程的相关操作
2.1 join
阻塞函数
join: 阻塞函数，在这段代码中表示，主线程阻塞，等待MyThread1运行完后再结束
int main() {
cout << "你好\n";
thread MyThread1(MyPrint);//接收可调用对象
MyThread1.join();//jion，阻塞，等待MyThread运行结束后在继续运行主线程
cout<<"Main finish!\n";
return 0;
}
2.2 detach
分离函数
detach：分离函数，分离子线程和主线程，调用后，主线程是否结束不会影响子线程的运行
用的比较少，因为子线程不可控
int main() {
cout << "你好\n";
thread MyThread1(MyPrint);
MyThread1.detach();
cout<<"Main finish!\n";
return 0;
}
调用detach后，线程转入后台运行。此时被C++运行时库接管，当子线程执行完毕后，由运行时库负责清理线程资源。
一旦detach，就无法join，因为失去了关联。
所以detach应用的情况相对较少
2.3 joinable
判断函数
joinable：判断线程是否能join或者detach，返回ture或false
因为很多时候我们不知道某个线程能否join或者detach，所以需要用这个进行判断
三、线程参数
3.1传参所引发的资源回收问题
void myprint(const int &i,char* p){
cout<<i<<endl<<p<<endl;
}
int main(){
int a=10;
char mystr[]="hello world";
thread myth(myprint,myI,mystr);//线程传参
myth.join()
//myth.detach();
}
看上述例子，如果detach分离了线程的话，有可能造成主线程已经结束，但是myth未结束的情况，则此时str已经被系统回收，p所指向的内容就不确定，程序出错
所以，为了避免资源被系统回收，使用临时变量
thread myth(myprint,myI,string(mystr));//线程传参
当使用了临时对象后，便没有出现资源被回收程序出问题的情况
为什么使用临时对象就不会出现问题？
猜想：使用临时对象是进行了资源的拷贝？
为了验证猜想，自己写一个类
class TA {
int a;
public:
void operator()() {//仿函数
cout << "线程TA开始执行了" << endl;
}
TA() = default;
TA(int b) {
this->a = b; //获取当前线程的id
cout << "构造函数！TA() id = " << std::this_thread::get_id() << "\taddr = " << this << endl;
}
TA(const TA &t) {
this->a = t.a;
cout << "拷贝构造TA(const TA & t) id = " << std::this_thread::get_id() << "\taddr = " << this << endl;
}
void work(int num){
cout<<"子线程work执行 "<< this<<" id = "<<std::this_thread::get_id()<<endl;
}
~TA() {
cout << "析构函数 id = " << std::this_thread::get_id() << "\taddr = " << this << endl;
}
};
void myprint2(const TA &ta) {//class类型参数 即使是引用，仍会进行拷贝，值传递
cout << "子线程开始 " << "addr = " << &ta << "\t子线程id = " << std::this_thread::get_id() << endl;
}
传入a为int类型，可是函数参数类型为TA，此时会发生隐式类型转化，调用构造函数，将int转为TA类型
int main(){
cout << "main id = " << std::this_thread::get_id() << endl;
int a=1
thread myobj(myprint2, a);//发现对象构造是在子线程中
myobj.join();
}
运行结果:
main id = 139656476180864
构造函数！TA() id = 139656476165696 addr = 0x7f044ea6fd74
子线程开始 addr = 0x7f044ea6fd74 子线程id = 139656476165696
析构函数 id = 139656476165696 addr = 0x7f044ea6fd74
可以看出，由于入口函数参数为类型TA，程序发生隐式转换，用变量a构造了一个临时对象，再将临时对象传入入口函数。并且可以观察到，构造对象的过程并不是在主线程完成的，而是在子线程中进行。所以我们可以推测，如果使用detach，就有可能造成主线程比子线程先结束，导致a被回收，从而构造出现问题，引发程序异常！大家不妨可以试试join改为detach，多运行几次可能就会发现问题所在。
那我们如何解决这类问题呢
不要使用隐式转换，自己完成强转操作
int main(){
cout << "main id = " << std::this_thread::get_id() << endl;
int a=1
thread myobj(myprint2, TA(a));
myobj.join();
}
运行结果:
main id = 139705515577728
构造函数！TA() id = 139705515577728 addr = 0x7ffd013a24a8
拷贝构造TA(const TA & t) id = 139705515577728 addr = 0x55a7c06ad2c8
析构函数 id = 139705515577728 addr = 0x7ffd013a24a8
子线程开始 addr = 0x55a7c06ad2c8 子线程id = 139705515562560
析构函数 id = 139705515562560 addr = 0x55a7c06ad2c8
通过上一例子可以看出，首先在主线程构造了一个临时变量，由 TA(a)引起，因为这一对象很快被析构了，所以我们判断它是临时对象，这很容易理解；然后发生了拷贝构造，并且拷贝构造依然发生在主线程，并且可以看到，拷贝出来的对象进入到了子线程去执行，我们就可以推测，临时对象作为入口函数的参数，子线程会对其进行拷贝。
因此，在detach一个线程时，我们尽量不要让编译器对参数进行隐式类型转化，这样有可能引发传入资源被回收的问题！对应的解决办法就是自己对其进行转化
我们还可以看出，即使子线程入口函数的的参数是引用类型，传参是仍然是拷贝构造，相当于就是值传递，那如果我们需要子线程对某一数据进行更改，需要传入引用怎么办呢？
使用std::ref()
int main(){
cout << "main id = " << std::this_thread::get_id() << endl;
int a=1
TA ta(a);
thread myobj(myprint2, std::ref(ta));
myobj.join();
}
运行结果:
main id = 139781778977152
构造函数！TA() id = 139781778977152 addr = 0x7fffd0ec9d00
子线程开始 addr = 0x7fffd0ec9d00 子线程id = 139781778961984
析构函数 id = 139781778977152 addr = 0x7fffd0ec9d00
可以很清除的看到，当我们使用了std::ref()时，构造函数在主线程中进行，并且子线程没有发生拷贝构造。传给子线程的是一个引用。此时我们将入口函数参数列表中的const修饰符去掉，就可以修改对象中的数据，编译器也不会报错。这种情况下应该注意被引用对象回收时间的问题。
3.2 将对象的成员函数作为入口函数
int main(){
cout << "main id = " << std::this_thread::get_id() << endl;
int a=1
TA ta(a);
thread myobj(&TA::work,ta, 1);//类的成员函数作线程入口，第三个参数传入的对象，第四个参数是work函数的参数
// 也可以使用引用
//thread myobj(&TA::work,&ta, 1); 等价于std::ref(ta) 不会调用拷贝构造
myobj.join();
}
类内线程创建
class Ta{
public:
Ta(){
std::thread t(std::bind(&Ta::task,this));
}
void task();
}
四、线程的互斥量的使用
很多时候，多个线程需要对同一数据进行操作，同时读取某一数据往往不会出现问题，而当由某些线程读取数据，某些线程又会写入数据时，往往会发生读写冲突。
我们试想一下，线程A在读取读取数据Data时，时间片结束，系统开始运行线程B，而线程B恰好要对Data进行修改，那么是不是会发生冲突。再想一下，一个线程对文件进行写入操作，结果写入结束还没保存并关闭文件时，时间片结束，另一个线程也访问这个文件，可是由于写文件线程没有保存文件，那么访问线程不就拿不到数据了吗。
所以引入了互斥量这一概念
当访问共享数据前，使用互斥量将相关数据锁住，再当访问结束后，再将数据解锁。多线程程序需要保证，当一个线程使用特定互斥量锁住共享数据时，其他的线程想要访问锁住的数据，都必须等到之前那个线程对数据进行解锁后，才能进行访问。这就保证了所有线程能看到共享数据
举个栗子
/* 假如说我们有很多用户，他对我们的系统下了很多指令，使用一个线程接收指令，将指令存入一个list中
* 再由另一个线程读取list中的指令
*/
class ReadWrite {
private:
std::list<int> M;
public:
void RecvMsg() { //接收指令的线程
for (size_t i = 0; i < 10000; ++i) {
cout << "RecvMsg insert a num=" << i << endl;
M.emplace_back(i);
}
}
void GetFromM() { //读取指令的线程
for (size_t i = 0; i < 10000; ++i) {
if (!M.empty()) {
int com = M.front(); //返回地一个元素，无论是否为空
M.pop_front(); //取出后移除
cout<<"cmd="<<com<<endl;
} else {
cout << "list is null\ti=" << i << endl;
}
}
cout << "Get end" << endl;
}
};
int main(){
ReadWrite r;
thread out(&ReadWrite::GetFromM, std::ref(r));
thread get(&ReadWrite::RecvMsg, std::ref(r));
get.join();
out.join();
cout << "main end" << endl;
}
上述代码在运行时会发生问题，由于涉及到了同步读写同一块内存区域的问题，要解决这个问题，需要引用mutex互斥量这个概念
#include<mutex>
class ReadWrite {
private:
std::list<int> M;
public:
void RecvMsg() { //接收指令的线程
for (size_t i = 0; i < 10000; ++i) {
cout << "RecvMsg insert a num=" << i << endl;
mymutex.lock();
M.emplace_back(i);
mymutex.unlock();
}
}
void GetFromM() { //读取指令的线程
for (size_t i = 0; i < 10000; ++i) {
mymutex.lock();
if (!M.empty()) {
int com = M.front(); //返回第一个元素，无论是否为空
M.pop_front(); //取出后移除
cout<<"cmd="<<com<<endl;
} else {
cout << "list is null\ti=" << i << endl;
}
mymutex.lock();
}
cout << "Get end" << endl;
}
};
int main(){
ReadWrite r;
thread out(&ReadWrite::GetFromM, std::ref(r));
thread get(&ReadWrite::RecvMsg, std::ref(r));
get.join();
out.join();
cout << "main end" << endl;
}
引入mutex，在对数据进行读写的时候，将把锁锁上，然后再操作数据，这样其他线程在试图访问的时候，由于锁被锁住了，其他线程也无法进行上锁操作，就会被阻塞，数据操作结束，将锁释放，让其他线程可以操作数据。
说的通俗一点，就像上厕所一样，上厕所之前要把门(mutex)先锁好(lock)，这样其他人访问厕所就会被门拦住，上完了后将门打开(unlock)，厕所就能被其他人用了
有一点一定要记住，就是加锁和解锁一定是成对出现的，否则其他线程就会进入无限等待的状态。所以C++标准库提供了类似智能指针的锁std::lock_guard，可以自动上锁自动解锁，当锁变量离开作用域时就会自动解锁，除此之外还可以使用std::unique_lock，相较于lock_guard更为灵活，它由不同的成员函数由用户自己控制何时加锁，能否加锁
unique_lock详解
在使用互斥量的时候，一定要注意死锁，死锁就是两个线程同时等待对方持有的某一资源，导致程序无法正常推进
比如说我们由两个锁A和B，线程1和线程2，线程一需要先锁A，然后锁B才能继续进行数据访问操作，而线程二需要先锁B再锁A才能进行数据访问操作。假设程序运行到某一时间点，线程一锁住了A，线程二锁住了B，而此时，线程一需要将B上锁，才能继续推进，可是B已经被线程二锁住了，于是线程一被阻塞了，必须等待B被解锁，同时线程二也是要等待A被解锁才能继续推进，程序再此刻便发生了死锁
解决死锁，只需要上锁的顺序一致便可，即线程一和线程二都是先上锁A再上锁B。使用std::lock就可以保证多个锁的顺序一致
除了std::mutex外，C++还提供了递归的独占互斥量std::recursive_mutex，它允许一个线程，同一个互斥量被lock多次
timed_mutex和recursive_timed_mutex
带超时功能的独占互斥量和带超时功能的递归独占互斥量
两个接口：try_lock_for和try_lock_until
try_lock_for：等待一段时间，超时未拿到锁则放弃，程序继续执行，参数为std::chrono::*
std::timed_mutex my_mutex;
std::chrono::milliseconds my_times(100);//100毫秒
my_mutex.try_lock_for(my_times);//等待100毫秒，如果100毫秒内获得锁，则返回false
try_lock_until：等待到某一个时间点
std::timed_mutex my_mutex;
std::chrono::milliseconds my_times(100);//100毫秒
my_mutex.try_lock_until(std::chrono::steady_clock::now()+my_times);//等待100毫秒，如果100毫秒内获得锁，则返回false
shared_mutex读写锁
可以理解为读写锁，允许多人读，单人写，但是写和读，写和写不能同时进行
可以直接lock和lock_shared，前者表示写的方式，一旦上锁，其他线程无法进入，后者表示读的方式，上锁后其他线程只能读，无法写
五、条件变量
5.1condition_variable
条件变量condition_vriable需要搭配互斥量使用，它是一个类，包含在同名的头文件中，有一些自己的成员函数，这里主要介绍
notify_one和wait函数
首先看一个例子
class MsgList {
private:
list<int> Command;
std::mutex mutex1;
std::condition_variable MyCod;
public:
void GetMsg() {
int cmd = 0;
while (true) {
std::unique_lock<std::mutex> guard(this->mutex1);//条件变量要与互斥量配合使用
this->MyCod.wait(guard, [this]() {
return !this->Command.empty();
});
cmd = Command.front();
Command.pop_front();
guard.unlock();
cout << "读取指令" << cmd << endl;
}
}
void PutMsg() {
for (size_t i = 0; i < 100000; ++i) {
std::unique_lock<std::mutex> guard(this->mutex1);
cout << "插入指令：" << i << endl;
Command.emplace_back(i);
this->MyCod.notify_one();
guard.unlock();//可要可不要，unique_lock的好处就在于可随时控制
}
}
};
int main(){
MsgList msgList;
thread Get(&MsgList::GetMsg, &msgList);
thread Put(&MsgList::PutMsg, &msgList);
Get.join();
Put.join();
cout << "main end" << endl;
}
两个线程Get和Put分别访问一个共享数据区，Get从共享区拿数据，Put往共享区放数据
5.2成员函数wait
this->MyCod.wait(guard, [this]() {return !this->Command.empty();});，这行代码表示，若list中没有数据则阻塞当前线程。
这行代码第一个参数是互斥量mutex，第二个参数是一个lambda表达式，用来判断list是否有数据
wait用于等一个信号，如果第二个参数返回值为false，那么wait将解锁互斥量并阻塞，即取消对临界区的占用并阻塞自己，直到有线程调用notify_one，如果其他线程notify了，当前线程唤醒，那么wait就会不断获取mutex(临界区的访问权)，直到获取到，然后往下走
如果没有参数，只需要看是否有线程唤醒自己，唤醒则往下走
除wait外, 条件变量还提供了wait_for和wait_until，前者用于等待指定时长，后者用于等待到指定的时间。
5.3成员函数notify_one
this->MyCod.notify_one();这行代码就是在Put线程完成了数据插入后，将Get线程唤醒，只能唤醒一个线程。
5.4 存在的问题
Put线程在执行notify的时候，如果Get没有被 wait() 所阻塞，那么唤醒操作就无效，此时Put就没有将Get叫起。
当线程Put获取到的时间片比较多时，list 中积压的数据就会比较多，这个时候是否考虑要对存数据的线程进行限流呢？
六、线程返回值
6.1future和async
std::future、std::async创建后台任务并返回值
std::future可以放置线程执行结束返回的结果值，可以调用get成员函数获取线程的返回值
std::async与创建线程用法无异
#include<future>
int myTh5_2(){
cout<<"mythread() start"<<" thread id="<<std::this_thread::get_id()<<endl;
std::chrono::milliseconds milliseconds(1000);
std::this_thread::sleep_for(milliseconds);//休息1000毫秒
cout<<"mythread() end"<<" thread id="<<std::this_thread::get_id()<<endl;
return 1;
}
int main(){
cout<<"main start; id="<<std::this_thread::get_id()<<endl;
std::future<int> result=std::async(myTh5_2);//未来的值
cout<<"continue"<<endl;
//get一定会等待子线程执行结束，仅能执行一次
cout<<"return "<<result.get()<<endl;//卡住，等待myTh执行结束
cout<<"main end"<<endl;
}
运行结果：
main start; id=140234514006400
continue
return mythread() start thread id=140234513991232
mythread() end thread id=140234513991232
1
main end
get()函数不拿到返回值，就会一直阻塞，还有wait()函数，只是会等待返回，不会获取返回值
使用std::launch::deferred延迟调用
std::future<int> result=std::async(std::launch::deferred,myTh5_2);
cout<<result.get();
当使用了deferred，只有执行了result.get()线程才会被执行
main start; id=140553532236160
continue
return mythread() start thread id=140553532236160
mythread() end thread id=140553532236160
1
main end
可以看见，没有创建主线程，入口函数是在主线程中执行
与之相对应的是std::launch::async，加入这个参数，表示线程会立即执行，而不是等到调用了get()后执行
6.2package_task
打包任务，一个类模板，参数是各种可调用对象，作用是将可调用对象包装起来，方便作为线程入口函数
用法示例：
cout << "main start; id=" << std::this_thread::get_id() << endl;
//表示要求可调用对象的返回值为int，参数类型为int
std::packaged_task<int(int)> packagedTask(myTh5_3);
thread th(std::ref(packagedTask), 1);
th.join();
std::future<int> res = packagedTask.get_future();
cout<<"res.get()="<<res.get()<<endl;
packaged_task还可以独自调用
std::packaged_task<int(int)> packagedTask1([](int a) -> int { cout << "a=" << a << endl; });
packagedTask1(5);//想当于函数调用
std::future<int> res1 = packagedTask1.get_future();
cout << "res1.get()=" << res1.get() << endl;
6.3std::promise
获取线程运行结果
通过promise保存一个值，在将来某一时刻通过future获取这个值
void myTh4(std::promise<int> &temp, int res) {
srand((int)time(0));
res++;
res *= (rand()%100+1);
std::chrono::milliseconds d(3000);
std::this_thread::sleep_for(d);
int result = res;
temp.set_value(result);
}
int main() {
std::promise<int> promise;
thread th(myTh4, std::ref(promise), 1);//使用这个，就可以在不同的线程传参
th.join();
std::future<int> fu = promise.get_future();
cout << "get res=" << fu.get() << endl;
}
//多线程应用
void myTh5(std::future<int> &f) {
cout << "thread id=" << std::this_thread::get_id() << "\tstart" << endl;
auto res = f.get();//等到有运算结果时才会继续
cout << "other thread return=" << res << endl;
}
void myTh4(std::promise<int> &temp, int res) {
srand((int) time(0));
res++;
res *= (rand() % 100 + 1);
cout << "thread id=" << std::this_thread::get_id() << "正在计算。" << endl;
std::chrono::milliseconds d(3000);
std::this_thread::sleep_for(d);
int result = res;
temp.set_value(result);
}
int main() {
std::promise<int> promise;
std::future<int> fu = promise.get_future();
thread th(myTh4, std::ref(promise), 1);//使用这个，就可一在不同的线程传参
thread th1(myTh5, std::ref(fu));
th1.join();
th.join();
}
使用
promise和future可以实现线程之间的通信，两个线程，一个线程计算，另一个线程等待计算结束后再继续运行
运行结果：
thread id=139657918248512 start
thread id=139657926641216 正在计算。
other thread return=88
但是一个future对象只能get一次，如果有多个线程需要获取这个值，可以使用shared_future，这样就可以get多次
void myTh4(std::promise<int> &temp, int res) {
srand((int) time(0));
res++;
res *= (rand() % 100 + 1);
cout << "thread id=" << std::this_thread::get_id() << "正在计算。" << endl;
std::chrono::milliseconds d(3000);
std::this_thread::sleep_for(d);
int result = res;
temp.set_value(result);
}
void myTh6(std::shared_future<int> &f) {
cout << "thread id=" << std::this_thread::get_id() << "\tstart" << endl;
auto res = f.get();
cout << "other thread return=" << res << endl;
}
void main() {
std::promise<int> promise;
std::shared_future<int> future = promise.get_future();
thread th1(myTh4, std::ref(promise), 1);
thread th3(myTh6, std::ref(future));
thread th2(myTh6, std::ref(future));
th1.join();
th2.join();
th3.join();
}
6.4future及其他
std::future<int> fu= std::async(std::launch::deferred, myTh5_2);
std::future_status status=fu.wait_for(std::chrono::seconds(1));//等待线程1秒
if(status==std::future_status::timeout)//超时 ready执行完了 deferred 延迟执行
七、原子操作
void myth6_1(int &a) {
cout << "write start! address:" << &a << endl;
for (size_t i = 0; i < 100000; ++i) {
a++;
}
}
void myth6_2(int &a) {
cout << "read start! address:" << &a;
for (size_t i = 0; i < 100000; ++i) {
cout << a << endl;
}
}
void test6_1() {
int a = 8;
cout << "address " << &a << "\ta=" << a << endl;
thread th1(myth6_1, std::ref(a));
thread th2(myth6_1, std::ref(a));
th2.join();
th1.join();
cout << "address " << &a << "\ta=" << a << endl;
}
运行结果：
address 0x7fff7c796f3c a=8
write start! address:0x7fff7c796f3c
write start! address:0x7fff7c796f3c
address 0x7fff7c796f3c a=192558
上述代码就是两个线程，对同一个变量执行+1操作
多运行几次会发现，出现的结果可能和我们预期不一样
因为+1操作不是原子操作，线程在进行+1操作的时候，可能突然失去时间片，导致操作未完成，就造成了最终结果比预期小的现象
原子操作：不会被打断的程序执行片段
原子操作效率比互斥量更胜一筹，互斥量一般是针对某一片代码，原子操作通常针对某一变量
原子对象关键字std::atomic
void myth6_1(std::atomic<int> &a) {
cout << "write start! address:" << &a << endl;
for (size_t i = 0; i < 1000000; ++i) {
a++;
}
}
void myth6_2(std::atomic<int> &a) {
cout << "read start! address:" << &a;
for (size_t i = 0; i < 1000000; ++i) {
cout << a << endl;
}
}
void main() {
std::atomic<int> a = 8;
cout << "address " << &a << "\ta=" << a << endl;
thread th1(myth6_1, std::ref(a));
thread th2(myth6_1, std::ref(a));
th2.join();
th1.join();
cout << "address " << &a << "\ta=" << a << endl;
}
将共享关键字封装为原子变量后，操作就不不会被打断，这样每次运行的结果就都正确了
一般用于统计，计数
使用原子操作实现操控线程结束
std::atomic<bool> gFlag = false;
void myth6_3() {
std::chrono::milliseconds d(1000);
while (!gFlag) { //为假时不让停
cout << "thread id = " << std::this_thread::get_id() << " running..." << endl;
std::this_thread::sleep_for(d);//休息一秒
}cout << "thread id = " << std::this_thread::get_id() << " stop..." << endl;
}
void main() {
thread th1(myth6_3);
thread th2(myth6_3);
std::chrono::milliseconds s(5000);
std::this_thread::sleep_for(s);
gFlag = true;//停止两个线程
th1.join();
th2.join();
}
运行结果:
thread id = 140360114566720 running...
thread id = 140360106174016 running...
thread id = 140360106174016 running...
thread id = 140360114566720 running...
thread id = 140360106174016 running...
thread id = 140360114566720 running...
thread id = 140360106174016 running...
thread id = 140360114566720 running...
thread id = 140360106174016 running...
thread id = 140360114566720 running...
thread id = 140360106174016 stop...
thread id = 140360114566720 stop...
在上上个例子中，如果将原子变量的a++操作改为a=a+1，那么结果又会不符合我们预期
一般只针对++,--,+=,&=,|=,^=适用
八、async深入
上文讲过，std::launch::deferred是延迟调用，std::launch::async是强制创建一个线程
在使用std::thread()创建线程时，如果系统资源紧张，那么可能会创建失败，程序崩溃
std::async一般称之为创建一个异步任务
上文提到过，使用了deferred延迟调用后，甚至不会创建一个新的线程，只有调用了get或者wait才会开始执行入口函数
当使用sync创建任务时std::future<int> result = std::async(std::launch::deferred, myTh5_2);，若第一个参数没有指定，默认为std::launch::deferred | std::launch::async，意思就是让系统决定是异步(创建)还是同步(不创建)运行。
