C++thread线程相关
声明：本文是在GitHub上找的代码，本文做了一些简单的增减。希望能够给想学习c++多线程的童鞋们提供一点帮助，当然也是为了自己以后复习的时候能够有个地方看以前写的东西。**
（一）线程/进程基本概念
1. 进程
进程是资源调度的基本单位，运行一个可执行程序会创建一个或多个进程，进程就是运行起来的可执行程序
2. 线程
线程是程序执行的基本单位，是轻量级的进程。每个进程中都有唯一的主线程，且只能有一个，主线程和进程是相互依存的关系，主线程结束进程也会结束。
3. 并发（多线程）
多个线程同时执行，由于处理器CPU个数有限，不同任务之间需要分时切换，这种切换是有开销的，操作系统需要保持切换时的各种状态。线程一多大量的时间用于切换，导致程序运行效率低下。
3.1 实现方法
-
多进程实现并发
进程之间可以通过管道，文件，消息队列，共享内存进程通信
不同电脑之间通过socket通信
-
单进程中多线程
一个进程中的所有线程共享地址空间（共享内存），例如：全局变量，指针、引用都可以在线程之间传递，因此使用多线程的开销比较小。
共享内存引入数据不一致问题，需要使用锁进行解决
3. 2 线程VS进程
- 线程启动速度快，轻量级
- 线程的系统开销小
- 使用有一定难度，需要处理数据一致性问题
（二）C++线程入门
1. 主线程与子线程
-
主线程执行完毕，整个进程也执行完毕，一般情况下，如果其他子线程没有执行完毕，那么这些子线程也会被操作系统强行终止。
-
子线程执行一个函数，函数运行完毕，子线程随之运行完毕。
-
一般情况下，如果想保持子线程的运行状态，需要保持主线程持续运行。
#include
#include
using namespace std;
void myprint(){
cout<< "子线程开始" < - 传统多线程，主线程需要要等待子线程结束之后才能结束。
- **join()**会阻塞线程，在子线程执行完毕之后，再与主线程汇合
- 新特性，使用**detach()**方法可以做到主线程和子线程分离，主线程可以先结束，而子线程继续运行。一旦detach()之后，主线程关联的Thread就会与主线程失去关联，子线程会驻留在后台运行，此时子线程由运行时库接管，子线程执行完后，由运行时库（守护线程）清理相关资源。
- 其他创建线程的方法
#include
#include
using namespace std;
//使用类对象（可调用对象）创建线程
class TA{
public:
int &m_i; //不建议在线程中使用引用和指针，这样detach时，主线程结束，相关变量被释放，导致子线程中使用不可预知的值
TA(int &i): m_i(i){
cout<< "构造函数开始执行" < ta在主线程结束之后被立即释放，为什么线程中的类对象还能正常调用类相关函数？
原因在于ta被拷贝了一份到子线程中，因此主线程退出清理ta并不影响子线程中的ta，通过拷贝构造函数可以验证这一过程。程序运行的结果如下：
（三）线程传参
1. 传递临时对象做为线程参数
#include
#include
using namespace std;
void myprint(const int & i, char *pmybuf){
cout << i < 多运行几次结果如下图，这就是一个典型的问题，原因在于子线程使用的detach，主线程已经退出了但是子线程还在执行，主线程退出了就会释放指针指向的内容，因此不会将字符串打印出来。
上述代码中，传入引用没有问题，但是不推荐，因为会创建一个新的引用地址，并不是真正意义上的引用，第二个参数为指针一定会有问题，因为该指针所指向的内容可能在主线程结束时被释放。
#include
#include
#include
using namespace std;
void myprint(const int & i, const string &pmybuf){
cout << i < 总结：
- 若传递基本类型的参数建议直接使用值传递
- 传递类对象时，避免隐式类型转换，应该在创建线程时构建临时对象（会在主线程中构建完成），线程参数使用引用参数来接收实参（否则对象会创建3次：1次为构建临时对象，2次为临时对象传入触发拷贝对象函数，3次为线程中复制触发拷贝构造函数）
- 非特殊情况尽量使用join()
2. 线程id
每个线程都有唯一的id。代码中使用std::this_thread::get_id()获取线程id
3. 传入类对象、智能指针
-
在线程中传入类对象时，不论函数形参是不是引用，都会得到一个新的拷贝对象，此时修改该对象并不影响实参。如何解决这个问题？
使用std::ref()函数，同时使用join()可以使传入的参数始终为同一个对象。
-
智能指针unique_ptr在传入线程时，需要使用std::move()函数将参数传入，此时线程形参接收到的地址和原地址一致，但是主线程中的智能指针为空，需要注意的是必须使用join()，使用detach()可能导致主线程将智能指针所指对象释放而在线程中使用的情况，造成未知错误。
（四）多线程和数据共享
1. 创建并等待多个线程
#include
#include
#include
using namespace std;
void myprint(int i){
cout << "Thread start ..." < myThreads; //使用容器存储线程
//创建10个线程
for(int i = 0; i<10; i++){
myThreads.push_back(thread(myprint, i));
}
//让主线程等待10个线程运行完成
for(auto iter = myThreads.begin();iter!=myThreads.end(); ++iter){
iter->join();
}
cout << "Main Thread end..." << endl;
return 0;
}
下图是程序运行的结果，产生这种结果的原因是多线程的并发问题，多个线程同时执行，此时cpu的时间片会不停的轮转，所以说线程执行和结束的顺序会产生一些不同，但是可以清楚的看到不管顺序有多乱，但是因为使用的是join()，因此主进程是在子进程执行完之后才结束的。
2. 数据共享
2.1. 只读数据
只读数据是安全稳定的，直接读就行。
2.2 有读有写
需要特殊的处理，避免程序崩溃。写的时候不能读，任意两个线程不能同时写，其他线程不能同时读。
2.3 共享数据代码
#include
#include
#include
#include
using namespace std;
class A{
public:
//插入消息，模拟消息不断产生
void insertMsg(){
for(int i = 0; i < 10000; i++){
cout<< "插入一条消息:" << i << endl;
Msg.push_back(i); //语句1
}
}
//读取消息
void readMsg(){
int curMsg;
for(int i = 0; i < 10000; i++){
if(!Msg.empty()){
//读取消息，读完删除
curMsg = Msg.front(); //语句2
Msg.pop_front();
cout << "消息已读出" << curMsg << endl;
}else{
//消息暂时为空
}
}
}
private:
std::list Msg; //消息变量
};
int main(){
A a;
//创建一个插入消息线程
std::thread insertTd(&A::insertMsg, &a); //这里要传入引用保证是同一个对象
//创建一个读取消息线程
std::thread readTd(&A::readMsg, &a); //这里要传入引用保证是同一个对象
insertTd.join();
readTd.join();
return 0;
}
多运行几次就会出现这样的报错，原因在于写入线程还没有将数据写入，读取线程就开始都线程，并且将读到的内容删除，这样就会导致崩溃。
上述代码在执行的过程中有问题，原因在于语句1在执行插入操作的时候，语句2可能进行读和删除的操作，导致线程运行不稳定。解决方法：引入**互斥量（Mutex）**的概念。
（五）互斥量与死锁
1. 互斥量的基本概念
多个线程同时操作一个数据的时候，需要对数据进行保护，可以使用锁，让其中一个线程进行操作，其他线程处于等待状态。
互斥量可以理解成一把锁，多个线程尝试使用lock()函数对数据进行加锁，只有一个线程能锁定成功，其他线程会不断的尝试去锁数据，直到锁定成功。
互斥量使用需要小心，保护太多影响效率，保护不够会造成错误。
#include
#include
#include
#include
#include //引入互斥量头文件
using namespace std;
class A{
public:
//插入消息，模拟消息不断产生
void insertMsg(){
for(int i = 0; i < 10000; i++){
cout<< "插入一条消息:" << i << endl;
my_mutex.lock();
Msg.push_back(i);
my_mutex.unlock();
}
}
//读取消息
void readMsg() {
int MsgCom;
for (int i = 0; i < 10000; i++) {
if (MsgLULProc(MsgCom)) {
//读出消息了
cout << "消息已读出" << MsgCom << endl;
}
else {
//消息暂时为空
cout << "消息为空" << endl;
}
}
}
//加解锁代码
bool MsgLULProc(int &command) {
my_mutex.lock(); //语句1
if (!Msg.empty()) {
//读取消息，读完删除
command = Msg.front();
Msg.pop_front();
my_mutex.unlock(); //语句2
return true;
}
my_mutex.unlock();//语句3
return false;
}
private:
std::list Msg; //消息变量
std::mutex my_mutex; //互斥量对象
};
int main(){
A a;
//创建一个插入消息线程
std::thread insertTd(&A::insertMsg, &a); //这里要传入引用保证是同一个对象
//创建一个读取消息线程
std::thread readTd(&A::readMsg, &a); //这里要传入引用保证是同一个对象
insertTd.join();
readTd.join();
return 0;
}
这里将上述代码中的后面一句unlock注释掉，会产生下面的错误，因此lock和unlock必须是一一对应的，绝对不能单独使用。
2. 互斥量的用法
互斥量是一个对象。
2.1 lock和unlock
- lock()和unlock()必须成对使用，且只能出现一次，否则代码不稳定。
- 上述代码中，语句1中的lock()和后续语句2和3的unlock()成对出现，缺失任意一个unlock()都会导致程序崩溃。
2.2 std::lock_guard类模板
lock_guard的提出是为了防止程序员在使用lock()的时候忘记unlock()的情况，可以直接取代这两个函数，使用lock_guard之后不能再使用这两个函数。使用方式如下：
bool MsgLULProc(int &command) {
//my_mutex.lock(); //语句1
std::lock_guard lgmutex(my_mutex); //使用lock_guard代替lock
if (!Msg.empty()) {
//读取消息，读完删除
command = Msg.front();
Msg.pop_front();
//my_mutex.unlock(); //语句2 *使用lock_guard之后不需要自己手动释放锁
return true;
}
//my_mutex.unlock();//语句3 *使用lock_guard之后不需要自己手动释放锁
return false;
}
代码中语句1在lock_guard的构造函数中执行，mutex::lock()，在其析构的时候执行mutex::unlock()，由此保证了互斥量的正常使用。
lock_guard缺点是没有lock和unlock使用灵活，需要手动析构。可以使用{}包裹，达到提前析构的目的。见如下代码。
//插入消息，模拟消息不断产生
void insertMsg(){
for(int i = 0; i < 10000; i++){
cout<< "插入一条消息:" << i << endl;
//在{}包裹内，lock_guard在{}结束时会自动析构，相当于unlock
{
std::lock_guard lgmutex(my_mutex);
Msg.push_back(i);
}
}
return;
}
这里有一点需要额外注意：一旦使用了lock_guard之后，不能再使用lock和unlock。
3. 死锁
死锁是指两个（多个）线程相互等待对方数据的过程，死锁的产生会导致程序卡死，不解锁程序将永远无法进行下去。
3.1 死锁产生原因
举个例子：两个线程A和B，两个数据1和2。线程A在执行过程中，首先对资源1加锁，然后再去给资源2加锁，但是由于线程的切换，导致线程A没能给资源2加锁。线程切换到B后，线程B先对资源2加锁，然后再去给资源1加锁，由于资源1已经被线程A加锁，因此线程B无法加锁成功，当线程切换为A时，A也无法成功对资源2加锁，由此就造成了线程AB双方相互对一个已加锁资源的等待，死锁产生。
理论上认为死锁产生有以下四个必要条件，缺一不可：
- 互斥条件：进程对所需求的资源具有排他性，若有其他进程请求该资源，请求进程只能等待。
- 不剥夺条件：进程在所获得的资源未释放前，不能被其他进程强行夺走，只能自己释放。
- 请求和保持条件：进程当前所拥有的资源在进程请求其他新资源时，由该进程继续占有。
- 循环等待条件：存在一种进程资源循环等待链，链中每个进程已获得的资源同时被链中下一个进程所请求。
3.2 死锁演示
通过代码的形式进行演示，需要两个线程和两个互斥量。
#include
#include
#include
#include
#include //引入互斥量头文件
using namespace std;
class A {
public:
//插入消息，模拟消息不断产生
void insertMsg() {
for (int i = 0; i < 10000; i++) {
cout << "插入一条消息:" << i << endl;
my_mutex1.lock(); //语句1
my_mutex2.lock(); //语句2
Msg.push_back(i);
my_mutex2.unlock();
my_mutex1.unlock();
}
}
//读取消息
void readMsg() {
int MsgCom;
for (int i = 0; i < 10000; i++) {
MsgCom = MsgLULProc(i);
if (MsgLULProc(MsgCom)) {
//读出消息了
cout << "消息已读出" << MsgCom << endl;
}
else {
//消息暂时为空
cout << "消息为空" << endl;
}
}
}
//加解锁代码
bool MsgLULProc(int &command) {
int curMsg;
my_mutex2.lock(); //语句3
my_mutex1.lock(); //语句4
if (!Msg.empty()) {
//读取消息，读完删除
command = Msg.front();
Msg.pop_front();
my_mutex1.unlock();
my_mutex2.unlock();
return true;
}
my_mutex1.unlock();
my_mutex2.unlock();
return false;
}
private:
std::list Msg; //消息变量
std::mutex my_mutex1; //互斥量对象1
std::mutex my_mutex2; //互斥量对象2
};
int main() {
A a;
//创建一个插入消息线程
std::thread insertTd(&A::insertMsg, &a); //这里要传入引用保证是同一个对象
//创建一个读取消息线程
std::thread readTd(&A::readMsg, &a); //这里要传入引用保证是同一个对象
insertTd.join();
readTd.join();
return 0;
}
语句1和语句2表示线程A先锁资源1，再锁资源2，语句3和语句4表示线程B线索资源2再锁资源1，具备死锁产生的条件。
程序运行到这里已然产生了死锁，不会再继续往下运行。
3.3 死锁的解决方案
保证上锁的顺序一致。
3.4 std::lock()
功能：锁住两个或两个以上的互斥量，解决因lock()顺序问题导致的死锁问题。
在时间使用过程中，只要有一个互斥量没锁住，就会进行等待，等所有互斥量都做锁住时，程序才继续进行。
要么多个互斥量都锁住，要么都没锁住，只要有一个没锁成功，会立即释放所有已经加锁的互斥量。代码如下：
void insertMsg(){
for(int i = 0; i < 10000; i++){
cout<< "插入一条消息:" << i << endl;
std::lock(my_mutex1, my_mutex2);//顺序无所谓
Msg.push_back(i);
my_mutex2.unlock();
my_mutex1.unlock();
}
}
该函数一次能锁定多个互斥量，小心使用，多个互斥量的时候建议逐个lock()和unlock()。
3.5 std::lock_guard的std::adopt_lock参数
std::adopt_lock是一个结构体对象，起一个标记作用就是表示这个互斥量已经lock()，不需要在std::lock_guard
void insertMsg(){
for(int i = 0; i < 10000; i++){
cout<< "插入一条消息:" << i << endl;
std::lock(my_mutex1, my_mutex2);//顺序无所谓
//加上adopt_lock参数可以使互斥量不再次进行lock()
std::lock_guard lgmutex1(my_mutex1, std::adopt_lock);
std::lock_guard lgmutex2(my_mutex2, std::adopt_lock);
Msg.push_back(i);
}
}
（六）unique_lock的使用
6.1 作用描述
std::unique_lock可以完全取代std::lock_guard，在使用上更加灵活。
6.2 参数说明
- std::adopt_lock：标记作用，如果互斥量已经lock，则不需要再lock;
- std::try_to_lock：尝试去lock，如果没有锁定成功，会立即返回而不会阻塞，注意其之前不能先lock;
- std::defer_lock: 初始化一个未加锁的mutex，其之前也不能先lock，否则会报异常，在之后操作锁的时候需要手动给其加锁，比如try_lock()。
6.3 成员函数
- lock()：给互斥量加锁；
- unlock：互斥量解锁；
- try_lock()：尝试给互斥量加锁，如果拿不到锁，则返回false，不阻塞；
- release()：释放互斥量的所有权，返回所管理的mutex对象指针，此后unique_lock和mutex不再有关系，如果，mutex处于加锁状态，则负责接管的对象需要负责解锁
6.4 unique_lock转移所有权的方式
- 使用std::move()函数进行转移
- 创建函数返回临时unique_lock对象
#include
#include ul(my_mutex);
//Msg.push_back(i);
//cout << "插入一条消息:" << i << endl;
< adopt和try_to_lock两个函数的解释
//my_mutex.lock();
//std::unique_lock ul(my_mutex, std::adopt_lock); //std::adopt_lock标记已经加锁,前面需要lock
//std::unique_lock ul(my_mutex, std::try_to_lock); //std::try_to_lock尝试加锁,前面不能先lock
< defer_lock()初始化未加锁的mutex
//std::unique_lock ul(my_mutex, std::defer_lock); //std::defer_lock初始化一个未加锁的mutex，其之前也不能先lock，否则会报异常
//if (ul.try_lock()) { //判断是否拿到锁
// //拿到锁
// Msg.push_back(i);
//}
//else
//{
// //没有拿到锁
// cout << "写数据线程没有拿到锁" << endl;
//}
< release释放锁的所有权代码演示
//std::unique_lock ul(my_mutex); //演示所有权释放
//Msg.push_back(i);
//std::mutex * p_m = ul.release(); //接管的互斥量指针需要手动释放已加锁的互斥量
//p_m->unlock();
< 转移锁代码演示
std::unique_lock<std::mutex> ul(my_mutex); //演示所有权转移，需要使用移动语义
std::unique_lock<std::mutex> ul2 = std::move(ul);
Msg.push_back(i);
ul2.unlock();
}
}
//读取消息
void readMsg() {
int MsgCom;
for (int i = 0; i < 10000; i++) {
if (MsgLULProc(MsgCom)) {
//读出消息了
cout << "消息已读出" << MsgCom << endl;
}
else {
//消息暂时为空
cout << "消息为空" << endl;
}
}
}
//加解锁代码
bool MsgLULProc(int &command) {
std::unique_lock<std::mutex> ul(my_mutex);
//延迟1s
std::chrono::milliseconds dura(1000);
std::this_thread::sleep_for(dura);
if (!Msg.empty()) {
//读取消息，读完删除
command = Msg.front();
Msg.pop_front();
return true;
}
return false;
}
private:
std::list<int> Msg; //消息变量
std::mutex my_mutex; //互斥量对象
};
int main() {
A a;
//创建一个插入消息线程
std::thread insertTd(&A::insertMsg, &a); //这里要传入引用保证是同一个对象
//创建一个读取消息线程
std::thread readTd(&A::readMsg, &a); //这里要传入引用保证是同一个对象
insertTd.join();
readTd.join();
return 0;
}
（七）单例设计模式与数据共享
7.1 单例设计模式
单例类：指的是在程序中该类的实例只存在一个，其实现通常需要满足以下三个条件：
- 构造函数私有化
- 唯一的私有静态类实例成员变量
- 静态方法返回类实例
实例代码7-1：
#include
#include
#include
#include
#include //引入互斥量头文件
using namespace std;
class MyCAS{
private:
MyCAS(){}; //私有化构造函数，保证该类无法被new或者以MyCAS m方式生成实例
private:
static MyCAS * m_instance; //类实例
public:
static MyCAS * GetInstance(){ //返回类实例
if(m_instance == NULL){
m_instance = new MyCAS();
static GCclass gc;//用于回收上一句new产生的内存，在程序结束时会调用其析构函数
}
return m_instance;
}
//类中嵌套回收类，用于回收单例类实例，防止出现内存泄露
class GCclass{
~GCclass(){
if(MyCAS::m_instance){
delete MyCAS::m_instance;
MyCAS::m_instance = NULL;
}
}
};
};
//初始化单例类实例
MyCAS* MyCAS::m_instance = NULL;
int main(){
MyCAS *p_a = MyCAS::GetInstance(); //获取单例类对象，最好在使用多线程之前加载单例类实例
return 0;
}
7.2 数据共享
在多线程中，如果多个类同时创建单例类对象，需要进行互斥，因此引入互斥量进行加锁。在代码7-1中，加入互斥量并修改函数GetInstance():
std::mutex my_mutex; //引入互斥量
static MyCAS * GetInstance(){ //返回类实例
if(m_instance == NULL){//双重锁定，保证有一次实例化之后，不会再进行资源锁定
std::unique_lock myul(my_mutex);
if(m_instance == NULL){
m_instance = new MyCAS();
static GCclass gc;//用于回收上一句new产生的内存，在程序结束时会调用其析构函数
}
}
return m_instance;
}
7.3 call_once()函数
该函数的功能是保证在多线程中，某一个函数只能被执行一次，可以解决7.2中GetInstance()函数被多次调用的问题。需要与标记std::once_flag配合使用。
在代码7-1中，进行如下修改：
std::once g_flag; //引入once_flag标记
//增加函数
static void CreateInstance(){
m_instance = new MyCAS();
static GCclass gc;
}
//返回类实例
static MyCAS * GetInstance(){
std::call_once(g_flag,CreateInstance);
return m_instance;
}
运行结果如下图所示：使用call_once保证只产生一个单例类
（八）条件变量及其成员函数
8.1 condition_variable类
条件变量可以使用通知的方式实现线程同步，其履行发送者或者接受者的角色。
实例代码8-1：
#include //需要引入头文件
#include
#include
#include
using namespace std;
class A{
public:
//插入消息，模拟消息不断产生
void insertMsg(){
for(int i = 0; i < 10000; i++){
std::unique_lock myul; //加锁
cout<< "插入一条消息:" << i << endl;
Msg.push_back(i);
myul.notify_one(); //语句1
}
}
//读取消息
void readMsg(){
while(true){
std::unique_lock myul; //加锁
my_cond.wait(myul,[this]{ //语句2
if(!Msg.empty())
return true;
return false;
});
}
}
//加解锁代码
bool MsgLULProc(int &command){
int curMsg;
my_mutex.lock(); //语句1
if(!Msg.empty()){
//读取消息，读完删除
curMsg = Msg.front();
Msg.pop_front();
cout << "消息已读出" << curMsg << endl;
my_mutex.unlock(); //语句2
return true;
}
my_mutex.unlock();//语句3
return false;
}
private:
std::list Msg; //消息变量
std::mutex my_mutex; //互斥量对象
std::condition_variable my_cond; //条件变量
}
int main(){
A a;
//创建一个插入消息线程
std::thread insertTd(&A::insertMsg, &a); //这里要传入引用保证是同一个对象
//创建一个读取消息线程
std::thread readTd(&A::readMsg, &a); //这里要传入引用保证是同一个对象
insertTd.join();
readTd.join();
return 0;
}
8.2 wait()/notify_one()/notify_all()函数
语句2中使用wait()函数进行等待，第一个参数为unique_lock()类对象，第二个参数为lambda表达式，如果是true则直接返回，程序继续往下执行，如果为false，则将互斥量解锁，并阻塞到本行，直到有线程调用notify_one()成员函数将其唤醒（如语句2）。如果没有第二个参数，则默认为false。
**注意：**当wait()被唤醒后，会尝试重新拿锁，拿到则程序继续往下执行，notify_one()是唤醒一个处于wait状态的线程，如果有多个线程，则不确定会唤醒哪一个，而notify_all()是唤醒所有处于wait状态的线程。另外一点是，如果在notify的过程中，没有线程处于wait状态，则这个通知会丢失。
结语
本文转载自GitHub的一位大佬，本人做了一些增减。全文代码地址：https://github.com/wlonging/ThreadLearning，包含线程相关知识和一个线程池的项目。
代码都经过实际运行测验，如有问题，欢迎大家留言交流。