本文介绍了C++中的多线程概念，包括进程与线程的区别，如何创建线程，使用join()和detach()进行线程控制。接着讲解了互斥量在同步中的作用，以及lock_guard和unique_lock的使用来确保资源安全。此外，还探讨了异步线程future和shared_future的用法，以及线程池的概念和优势。
1. 关于C++多线程
进程：是操作系统分配和调度系统内存资源、CPU时间片等资源的基本单位，为正在运行的应用程序提供运行环境；
线程：是操作系统/CPU能够进行运算调度的最小单位，它被包含在进程之中，进程包含一个或者多个线程。
多线程：是实现并发/并行的手段，即多个线程同时执行，一般来说，进程可以理解为一件事情的完整解决方案，多线程就是把执行一件事情的完整步骤拆分为多个子步骤，然后这个多个子步骤同时进行。
C++多线程：使用多个函数实现各自功能，不同函数生成不同功能，并同时执行。（不同线程可能存在一定程度的执行先后顺序，总体上可以看做同时执行）。
2. C++多线程基础
2.1 创建线程
引入头文件 #include<thread> (C++11)，该头文件定义了thread类，创建一个线程即实例化一个该类的对象，实例化对象调用的构造函数需要传递一个参数，该参数即为函数名，thread th1(proc1) 如果传递进去的函数本身需要传递参数，实例化对象时将这些参数写到函数名后面，thread th1(proc1,a,b)。
线程阻塞方法：
- join()
- detach()
th1.join()，即该语句所在的线程写在main()函数里面，等待指定线程th1执行结束后，主线程再继续执行，即当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
阻塞线程的目的是调节各线程的先后执行顺序
#include<iostream>
#include<thread>
using namespace std;
void proc(int a)
{
cout << "我是子线程,传入参数为" << a << endl;
cout << "子线程中显示子线程id为" << this_thread::get_id()<< endl;
}
int main()
{
cout << "我是主线程" << endl;
int a = 9;
thread th2(proc,a);
cout << "主线程中显示子线程id为" << th2.get_id() << endl;
th2.join()；
return 0;
}2.2 互斥量使用
单位上有一台打印机（共享数据a），你要用打印机（线程1要操作数据a），同事老王也要用打印机(线程2也要操作数据a)，但是打印机同一时间只能给一个人用，此时，规定不管是谁，在用打印机之前都要向领导申请许可证（lock），用完后再向领导归还许可证(unlock)，许可证总共只有一个，没有许可证的人就等着在用打印机的同事用完后才能申请许可证(阻塞，线程1lock互斥量后其他线程就无法lock，只能等线程1unlock后，其他线程才能lock，那么，这个许可证就是互斥量。互斥量保证了使用打印机这一过程不被打断。
程序实例化mutex对象m，线程调用成员函数m.lock()会发生以下情况：
- 如果该互斥量当前未上锁，则调用线程将该互斥量锁住，直到调用unlock()之前，该线程一直拥有该锁。
- 如果该互斥量当前被锁住，则调用线程被阻塞,直至该互斥量被解锁。
互斥量使用首先需要
#include<mutex>
lock()与unlock()
#include<iostream>
#include<thread>
#include<mutex>
using namespace std;
mutex m;//实例化m对象，不要理解为定义变量
void proc1(int a)
{
m.lock();
cout << "proc1函数正在改写a" << endl;
cout << "原始a为" << a << endl;
cout << "现在a为" << a + 2 << endl;
m.unlock();
}
void proc2(int a)
{
m.lock();
cout << "proc2函数正在改写a" << endl;
cout << "原始a为" << a << endl;
cout << "现在a为" << a + 1 << endl;
m.unlock();
}
int main()
{
int a = 0;
thread th1(proc1, a);
thread th2(proc2, a);
th1.join();
th2.join();
return 0;
}使用lock_guard或者unique_lock能避免忘记解锁这种问题。
- lock_guard():
其原理是：声明一个局部的 lock_guard 对象，在其构造函数中进行加锁，在其析构函数中进行解锁。最终的结果就是：创建即加锁，作用域结束自动解锁。从而使用 lock_guard() 就可以替代lock() 与 unlock()。
通过设定作用域，使得 lock_guard 在合适的地方被析构（在互斥量锁定到互斥量解锁之间的代码叫做临界区（需要互斥访问共享资源的那段代码称为临界区），临界区范围应该尽可能的小，即lock互斥量后应该尽早unlock），通过使用{}来调整作用域范围，可使得互斥量m在合适的地方被解锁：
#include<iostream>
#include<thread>
#include<mutex>
using namespace std;
mutex m;//实例化m对象，不要理解为定义变量
void proc1(int a)
{
lock_guard<mutex> g1(m);//用此语句替换了m.lock()；lock_guard传入一个参数时，该参数为互斥量，此时调用了lock_guard的构造函数，申请锁定m
cout << "proc1函数正在改写a" << endl;
cout << "原始a为" << a << endl;
cout << "现在a为" << a + 2 << endl;
}//此时不需要写m.unlock(),g1出了作用域被释放，自动调用析构函数，于是m被解锁
void proc2(int a)
{
{
lock_guard<mutex> g2(m);
cout << "proc2函数正在改写a" << endl;
cout << "原始a为" << a << endl;
cout << "现在a为" << a + 1 << endl;
}//通过使用{}来调整作用域范围，可使得m在合适的地方被解锁
cout << "作用域外的内容3" << endl;
cout << "作用域外的内容4" << endl;
cout << "作用域外的内容5" << endl;
}
int main()
{
int a = 0;
thread proc1(proc1, a);
thread proc2(proc2, a);
proc1.join();
proc2.join();
return 0;
}lock_gurad也可以传入两个参数，第一个参数为adopt_lock标识时，表示已经锁定，不再构造函数中不再进行互斥量锁定，因此此时需要提前手动锁定
#include<iostream>
#include<thread>
#include<mutex>
using namespace std;
mutex m;//实例化m对象，不要理解为定义变量
void proc1(int a)
{
m.lock();//手动锁定
lock_guard<mutex> g1(m,adopt_lock);
cout << "proc1函数正在改写a" << endl;
cout << "原始a为" << a << endl;
cout << "现在a为" << a + 2 << endl;
}//自动解锁
void proc2(int a)
{
lock_guard<mutex> g2(m);//自动锁定
cout << "proc2函数正在改写a" << endl;
cout << "原始a为" << a << endl;
cout << "现在a为" << a + 1 << endl;
}//自动解锁
int main()
{
int a = 0;
thread proc1(proc1, a);
thread proc2(proc2, a);
proc1.join();
proc2.join();
return 0;
}unique_lock类似于lock_guard,只是unique_lock用法更加丰富，同时支持lock_guard()的原有功能。
使用lock_guard后不能手动lock()与手动unlock();使用unique_lock后可以手动lock()与手动unlock();
unique_lock的第二个参数，除了可以是adopt_lock,还可以是try_to_lock与defer_lock;
try_to_lock: 尝试去锁定，得保证锁处于unlock的状态，然后尝试现在能不能获得锁；尝试用mutx的lock()去锁定这个mutex，但如果没有锁定成功，会立即返回，不会阻塞在那里
defer_lock: 始化了一个没有加锁的mutex
#include<iostream>
#include<thread>
#include<mutex>
using namespace std;
mutex m;
void proc1(int a)
{
unique_lock<mutex> g1(m, defer_lock);//始化了一个没有加锁的mutex
cout << "不拉不拉不拉" << endl;
g1.lock();//手动加锁，注意，不是m.lock();注意，不是m.lock();注意，不是m.lock()
cout << "proc1函数正在改写a" << endl;
cout << "原始a为" << a << endl;
cout << "现在a为" << a + 2 << endl;
g1.unlock();//临时解锁
cout << "不拉不拉不拉" << endl;
g1.lock();
cout << "不拉不拉不拉" << endl;
}//自动解锁
void proc2(int a)
{
unique_lock<mutex> g2(m,try_to_lock);//尝试加锁，但如果没有锁定成功，会立即返回，不会阻塞在那里；
cout << "proc2函数正在改写a" << endl;
cout << "原始a为" << a << endl;
cout << "现在a为" << a + 1 << endl;
}//自动解锁
int main()
{
int a = 0;
thread proc1(proc1, a);
thread proc2(proc2, a);
proc1.join();
proc2.join();
return 0;
}unique_lock所有权的转移
mutex m;
{
unique_lock<mutex> g2(m,defer_lock);
unique_lock<mutex> g3(move(g2));//所有权转移，此时由g3来管理互斥量m
g3.lock();
g3.unlock();
g3.lock();
}2.3 异步线程
添加头文件
#include<future>- async与future
async是一个函数模板，用来启动一个异步任务，它返回一个future类模板对象，future对象起到了占位的作用，刚实例化的future是没有储存值的，但在调用future对象的get()成员函数时，主线程会被阻塞直到异步线程执行结束，并把返回结果传递给future，即通过FutureObject.get()获取函数返回值。
相当于你去办政府办业务（主线程），把资料交给了前台，前台安排了人员去给你办理（async创建子线程），前台给了你一个单据（future对象），说你的业务正在给你办（子线程正在运行），等段时间你再过来凭这个单据取结果。过了段时间，你去前台取结果，但是结果还没出来（子线程还没return），你就在前台等着（阻塞），直到你拿到结果（get()）你才离开（不再阻塞）。
#include <iostream>
#include <thread>
#include <mutex>
#include<future>
using namespace std;
double t1(const double a, const double b)
{
double c = a + b;
return c;
}
int main()
{
double a = 2.3;
double b = 6.7;
future<double> fu = async(t1, a, b);//创建异步线程线程，并将线程的执行结果用fu占位；
cout << "正在进行计算" << endl;
cout << "计算结果马上就准备好，请您耐心等待" << endl;
cout << "计算结果：" << fu.get() << endl;//阻塞主线程，直至异步线程return
//cout << "计算结果：" << fu.get() << endl;//取消该语句注释后运行会报错，因为future对象的get()方法只能调用一次。
return 0;
}shared_future
future与shard_future的用途都是为了占位，但是两者有些许差别。
future的get()成员函数是转移数据所有权;shared_future的get()成员函数是复制数据。
因此：
- future对象的get()只能调用一次；无法实现多个线程等待同一个异步线程，一旦其中一个线程获取了异步线程的返回值，其他线程就无法再次获取。
- shared_future对象的get()可以调用多次；可以实现多个线程等待同一个异步线程，每个线程都可以获取异步线程的返回值。
2.4 原子类型automic
- 原子操作是最小的且不可并行化的操作。
意味着即使是多线程，也要像同步进行一样同步操作atomic对象，从而省去了mutex上锁、解锁的时间消耗。
// C++ Standard: C++17
#include <iostream>
#include <thread>
#include <atomic>
using namespace std;
atomic_int n（0）;
void count10000() {
for (int i = 1; i <= 10000; i++) {
n++;
}
}
int main() {
thread th[100];
for (thread &x : th)
x = thread(count10000);
for (thread &x : th)
x.join();
cout << n << endl;
return 0;
}
3 线程池
不采用线程池时：
创建线程 -> 由该线程执行任务 -> 任务执行完毕后销毁线程。即使需要使用到大量线程，每个线程都要按照这个流程来创建、执行与销毁。
虽然创建与销毁线程消耗的时间 远小于 线程执行的时间，但是对于需要频繁创建大量线程的任务，创建与销毁线程 所占用的时间与CPU资源也会有很大占比。
为了减少创建与销毁线程所带来的时间消耗与资源消耗，因此采用线程池的策略：
程序启动后，预先创建一定数量的线程放入空闲队列中，这些线程都是处于阻塞状态，基本不消耗CPU，只占用较小的内存空间。
接收到任务后，线程池选择一个空闲线程来执行此任务。
任务执行完毕后，不销毁线程，线程继续保持在池中等待下一次的任务。
线程池所解决的问题：
(1) 需要频繁创建与销毁大量线程的情况下，减少了创建与销毁线程带来的时间开销和CPU资源占用。（省时省力）
(2) 实时性要求较高的情况下，由于大量线程预先就创建好了，接到任务就能马上从线程池中调用线程来处理任务，略过了创建线程这一步骤，提高了实时性。（实时）
扫一扫
1924
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
