C++并发与多线程

绝大部分内容摘录博客：C++11并发与多线程_胡胡浩特的博客-CSDN博客

只是略作添加。还可以参考博客：C++笔记（《C++新经典》）_烟雨平生、赵的博客-CSDN博客_c++新经典

B站视频c++11并发与多线程视频课程_哔哩哔哩_bilibili讲解比较详细，但是有点啰嗦，可以简要看看。

一、 并发、进程、线程的基本概念

1.并发 多个任务同时进行。（边听音乐边写作业，听音乐和写作是两不同的活动，但是同时进行。） 早期计算机只有一个CPU，为了同时间执行多个任务，我们规定在一定的时间间隔内执行程序，这样就可以在宏观上达到并行执行程序，但实际微观上是隔很短的时间不停的切换执行程序，这样看起来就像很多程序同时执行一样。 单核cpu（中央处理器）：某一个时刻只能执行一个任务，由操作系统调度，每秒钟进行多次所谓的“任务切换”。并发的假象（不是真正的并发），切换（上下文切换）时要保存变量的状态、执行进度等，存在时间开销； 随着硬件发展，出现了多处理器计算机：用于服务器和高性能计算领域。台式机：在一块芯片上有多核（一个CPU内有多个运算核心，对于操作系统来说，每个核心都是作为单独的CPU对待的）：双核，4核，8核，10核。能够实现真正的并行执行多个任务（硬件并发）

2.可执行程序 盘上的一个文件，window上是 .exe 结尾的文佳 ，Linux上面是 文件权限为 -rwxrw-r–的文件。 3.进程 可执行程序运行起来就是一个进程，总之就是一个运行的程序的过程就是进程。 4.线程 请先记住两件事：

每个进程都有一个主线程，这个主线程是唯一的。 当运行一个可执行程序，产生一个进程后，这个主线程也 随之默默启动起来了。

总结： 线程是用来执行代码的 把线程理解成一条代码执行的通路，一个新的线程就代表一条新的道路。 一个进程自动办好了一个主线程，主线程随着进程的默默启动并运行，并可以包括多个其他线程（非主线程，是需要用代码来创建其他线程），但创建线程的数量最大一般不建议超过200~300个，具体还要针对实际程序。 因为主线程是自动启动的，所以一个进程中最少也是有一个线程的。 多线程可以同时做多件事情，所以运行效率更高，但是并不容易评估和量化，仍旧需要在实际编程和实际项目中体会和调整。

二、并发的实现方法

1.多进程并发 多个程序同时运行。进程通讯三种方式：管道通讯、消息通讯和共享内存。 2.多线程并发 单个进程创建多个线程。线程通信代价更小，同一个进程的线程是共享地址空间，因此多线程并发开销更小。但是由于共享地址空间，数据一致性问题凸显。 3.总结 多线程并发的优缺点： 优点：线程启动速度更快，更轻量级，系统资源开销更少，执行速度更快。 缺点：使用起来有难度，要小心处理数据一致性问题。

三、线程启动、结束，创建线程多法、join，detach

程序运行起来，生成一个进程，该进程所属的主线程开始自动运行；当主线程从main（）函数返回，则整个进程执行完毕 主线程从main（）开始执行，那么我们自己创建的线程，也需要从一个函数开始运行（初始函数），一旦这个函数运行完毕，线程也结束运行 整个进程是否执行完毕的标志是：主线程是否执行完，如果主线程执行完毕了，就代表整个进程执行完毕了，此时如果其他子线程还没有执行完，也会被强行终止【一般情况】,会导致程序不稳定，一般情况下主线程应该等待子线程结束。

创建一个线程： 1.包含头文件thread 2.写初始函数 3.在main中创建thread

#include <iostream>
#include <thread>
using namespace std;

void myPrint()
{
	cout << "我的线程开始运行" << endl;
	//-------------
   	for(int i = 0,;i<10000;i++){
        pass;
    }
    cout << i << endl;
	//-------------
	cout << "我的线程运行完毕" << endl;
	return;
}

int main()
{
	//(1)thread创建一个类对象，创建了线程，线程执行起点（入口）是myPrint；(2)执行线程
	thread myThread(myPrint);  //可调用对象

	//(2)阻塞主线程并等待myPrint执行完，当myPrint执行完毕，join()就执行完毕，主线程继续往下执行
	//join意为汇合，子线程和主线程汇合
	//myThread.join();

	//设置断点可看到主线程等待子线程的过程
	//F11逐语句，就是每次执行一行语句，如果碰到函数调用，它就会进入到函数里面
	//F10逐过程，碰到函数时，不进入函数，把函数调用当成一条语句执行

	//(3)传统多线程程序中，主线程要等待子线程执行完毕，然后自己才能向下执行
	//detach:分离，主线程不再与子线程汇合，不再等待子线程
	//detach后，子线程和主线程失去关联，驻留在后台，由C++运行时库负责清理该线程相关的资源
    //如果子线程中采用引用来引用主线程中的变量，当主线程结束时，主线程被引用的变量也被释放，有风险。
	myThread.detach();

	//(4)joinable()判断是否可以成功使用join()或者detach()
	//如果返回true，证明可以调用join()或者detach()
	//如果返回false，证明调用过join()或者detach()，join()和detach()都不能再调用了
	if (myThread.joinable())
	{
		cout << "可以调用可以调用join()或者detach()" << endl;
        myThread.join();
	}
	else
	{
		cout << "不能调用可以调用join()或者detach()" << endl;
	}
	
	cout << "Hello World!" << endl;
    int b = 0;
	//-------------
	for (int i = 0; i < 1000000; i++) { //子线程进入的很慢，不知道为什么，将i加到100级别子线程才会有输出
		b += i;
	}
	cout << " b =  " << b << endl;
	return 0;
}

其他创建线程的方法：

①创建一个类，并编写圆括号重载函数，初始化一个该类的对象，把该对象作为线程入口地址

class Ta
{
public:
	void operator()() //不能带参数
	{
		cout << "我的线程开始运行" << endl;
		//-------------
		//-------------
		cout << "我的线程运行完毕" << endl;
	}
};

//main函数里的；问题：如果主线程结束了，那么主线程创建的ta对象也被释放了，不过这个ta对象是被赋值到
//子线程中，不是直接引用,ta复制产生的新对象仍然存在，所以只要对象里面没有引用，指针，不会产生问题
	Ta ta;
	thread myThread(ta);
	myThread.join();

②lambda表达式创建线程

//直接放到main函数中
auto lambdaThread = [] {
		cout << "我的线程开始执行了" << endl;
		//-------------
		//-------------
		cout << "我的线程开始执行了" << endl;
	};

	thread myThread(lambdaThread);
	myThread.join();

③把某个类中的某个函数作为线程的入口地址

class Data_
{
public:
    void GetMsg(){}
    void SaveMsh(){}
};
//main函数里
    Data_ s;
    //第一个&意思是取址，第二个&意思是引用，相当于std::ref(s)
    //thread oneobj(&Data_::SaveMsh,s)传值也是可以的
    //在其他的构造函数中&obj是不会代表引用的，会被当成取地址
    //调用方式：对象成员函数地址，类实例，[成员函数参数]
	//第二个参数可以传递对象s，也可以传递引用std::ref(s)或&s
	//传递s，会调用拷贝构造函数在子线程中生成一个新的对象
	//传递&，子线程中还是用的原来的对象，所以就不能detach，因为主线程运行完毕会把该对象释放掉
    thread oneobj(&Data_::SaveMsh,&s);
    thread twoobj(&Data_::GetMsg,&s);
    oneobj.join();
    twoobj.join();