c++11多线程学习笔记（一）

该博客为记录学习C++11标准线程库，可能有所遗漏，希望大家多多指教！

1. 线程和进程的区别

来自知乎

进程是被执行的应用程序(程序即指令(code)与数据(data)的集合)的实例(可以启动多个相同的应用程序，它们是不同的进程)，同时也是系统资源分配的最小单位(虚拟地址空间等资源，见下图)，一个进程中可以包含多个线程。

操作系统会为每个进程分配一定的虚拟地址空间，该虚拟地址空间由进程独享

线程则是CPU进行运算调度的最小单位。线程被包含在进程之中，是进程中的实际运作单位。一个进程中可以包含多个线程，这些线程可以同时执行不同的任务(例如一个线程监听用户输入，一个线程执行IO任务，它们是同时进行互相独立的)。同一个进程中的多个线程共享操作系统为该进程分配的系统资源(如虚拟地址空间，信号量等…)，但同时多个线程又独立的拥有各自的调用栈，寄存器环境，和线程本地存储(thread-local storage)。

一个操作系统中可以有多个进程，这些进程可以异步(同时)或同步(顺序)执行，操作系统为这些进程分配独立的系统资源。而进程中又可以拥有多个线程(至少一个)，这些线程共享进程的系统资源，线程又被称为轻量级的进程。

2. 并发与并行

并发是指的是在一个重叠的时间段内，有多个任务(两个以上的task)可以被启动，执行或者完成，但是这并不意味着，这些任务必须在这一时间段内的某一时刻同时被运行。比如在一个拥有单核CPU上计算机上，我们可以同时运行浏览器和文档编辑器程序，却并不会感受到任何操作上的延迟。这是因为操作系统采用了时间片轮转算法(Round-Robin，RR)，操作系统中的每个进程被分配了一定的时间段(时间片)，操作系统将CPU分配给某一进程让其在处理器上执行一个时间片。当进程占用CPU的时间超过时间片的时间后，将由计时器发起中断请求，随后操作系统保存该进程的执行状态并将其挂起，然后将CPU分配给另一个进程执行一个时间片。由于时间片划分的很短，而且进程间的切换(进程间的切换也被称为上下文切换Context switch)也很快，所以会给人一种好像多个进程在同时执行的错觉。(在进行context switch的时候也会占用一定的时间，需要保存将被挂起的进程的执行状态，还需要把将要执行的进程的指令与内存载入到缓存中，在这期间CPU无法执行其他指令，因而过多的context switch会降低CPU的效率。)

在单核CPU上同时运行进程A(红色)与进程B(蓝色)，灰色为Context switch所占用的CPU时间

并行是指在同一时刻有多个任务同时运行。比如在一个双核的CPU上，在A核心上运行浏览器进程，而在B核心上运行文档编辑器进程，在两个核心上运行的进程相互独立，同时运行(多进程并发)。又比如在一个游戏进程中，可以同时存在一个逻辑线程(处理游戏逻辑)和一个IO线程(处理IO任务)，它们可以同时运行在两个不同的CPU核心上(多线程并发)。(并发的概念是包含并行的，并行是多线程的一种形式，多线程是并发的一种形式。)

使用多进程并发时，进程的创建与销毁速度都比较慢，而且进程间的通信也比较复杂(需要通过套接字，管道等…)，但是操作系统会在进程间提供附加的保护机制，这可以我们更容易写出并发安全的代码。而使用多线程并发时，线程的创建与销毁速度则要更快，由于同一进程中的所有线程共享虚拟地址空间，因此线程间的通信开销要小得多，但由于缺少线程间的数据保护，可能会出现多个线程同时读写同一数据造成的数据不一致现象。

3. 多线程开启

3.1 以一个无参数无返回值的函数作为线程的入口

c++ 11中可以用std::thread函数开启一个新的线程，下面的例子用thread开启以函数print_msg为入口的线程。该函数无返回值，也无参数。

#include <thread>
#include <iostream>

using namespace std;

void print_msg() {
	for(int i = 0; i < 10; i ++) {
		cout << "This is my first thread!!" << endl;
	}
}


int main() {
	std::thread my_thread(print_msg); // 启动多线程
	for(int i = 0; i < 10; i ++) {
		cout << "main function print!!" << endl;
	}
	my_thread.join(); // 等待线程结束
	return 0;
}

运行之后发现，我们确实开启了另外一条线程。

3.2 std::thread成员函数join()与detach()

std::thread的成员函数join()就是让主线程等待（阻塞）子线程运行结束再返回。

与join成员函数相对应的另一个成员函数为detach()，需要注意的是一旦detach()之后其主程序就不再等待线程结束就直接返回，也就是子线程与主线程之间失去了联系，如果子线程没有运行结束，子线程就会驻留在后台运行，被c++运行时刻接管，当这个子线程运行结束后，由运行时库回收。

另外，线程一旦join()之后就不能再detach(),虽然编译的时候不会报错（g++环境)，但运行时崩溃！！！很崩溃对不，其实大神们也想到了在程序设计肯定有人会忘记是否detach()或者join()。因此引入了另外一个成员函数joinable(),该函数用以判断是否可以使用join()或detach,如果该函数返回true，则可以调用join()或者detach(),否则则不能。

#include <iostream>
#include <thread>
#include <iostream>

using namespace std;

void print_msg() {
	for(int i = 0; i < 10; i ++) {
		cout << "This is my first thread!!" << endl;
	}
}


int main() {
	std::thread my_thread(print_msg); // 启动多线程
	for(int i = 0; i < 10; i ++) {
		cout << "main function print!!" << endl;
	}
	my_thread.join(); // 等待线程结束
	if (my_thread.joinable()) {
		my_thread.detach();
	}
	return 0;
}

3.2 以一个带参数无返回值的函数作为线程的入口

其带参数无返回值的函数作为函数如何传递参数呢？其实相当简单，就实在创建std::thread的对象的时候第一个参数仍然是线程入口函数，第二个参数开始（包括第二个参数）传入线程入口函数的参数，如下所示：

#include <iostream>
#include <thread>
#include <iostream>

using namespace std;

void print_msg(int a, int b) {
	cout << "input first params is:" << a << endl;
	cout << "input second params is:" << b << endl;
}

int main() {
	std::thread my_thread(print_msg, 10, 15); // 启动多线程print_msg为子线程入口函数，10,15为该函数参数
	for(int i = 0; i < 10; i ++) {
		cout << "main function print!!" << endl;
	}
	my_thread.join(); // 等待线程结束
	return 0;
}

4.其他创建线程的手法

4.1 以一个重载（）运算符的类对象作为子线程的入口

以一个类创建子线程，该类必须重载运算符()才能作为子线程启动函数，同样的此种方法也可以传递参数。

#include <iostream>
#include <thread>
#include <iostream>

using namespace std;

class MyThreadStart {
public:
	void operator() (int a) {
		cout << "This is my thread start point!!!" << endl;
		// .....其他处理
		cout << "test !!! "<< a << endl;
	}
};


int main() {
	MyThreadStart mts; //定义一个重载了（）运算符对象
	std::thread my_thread(mts, 15); // 以重载括号运算符的类对象作为子线程的入口
	for(int i = 0; i < 10; i ++) {
		cout << "main function print!!" << endl;
	}
	my_thread.join(); // 等待线程结束
	return 0;
}

4.2 以一个类对象的成员函数作为入口函数

以类对象的成员函数作为线程的入口函数，thread的第一个参数为对象成员函数地址，第二个参数为该类的一个对象指针。

#include <iostream>
#include <thread>
#include <iostream>

using namespace std;

class MyThreadStart {
private:
	int a;// 成员变量
public:
	int get_a() {
		return a;
	}
	MyThreadStart(int b):a(b) {}
	void print_msg() {
		for(int i = 0; i < 10; i ++) {
			cout << "Thread function print!!" << endl;
		}
		a = 15;
		cout << a << endl; 
	}
};

int main() {
	MyThreadStart mts(5); //定义一个类对象

	// 以类对象的成员函数作为线程入口函数
	std::thread my_thread(&MyThreadStart::print_msg, &mts); 
	
	my_thread.join(); // 等待线程结束
	cout << mts.get_a() << endl;
	for(int i = 0; i < 10; i ++) {
		cout << "main function print!!" << endl;
	}
	return 0;
}

4.3 以lambda表达式作为线程的入口函数

#include <iostream>
#include <thread>
#include <iostream>

using namespace std;

int main() {
	auto x = [](int a){
		cout << "Lambda function!!!" << a << endl;
		cout << "Lambda function!!!" << a << endl;
		cout << "Lambda function!!!" << a << endl;
	};
	// 
	std::thread my_thread(x, 15); 
	
	for(int i = 0; i < 10; i ++) {
		cout << "main function print!!" << endl;
	}
	my_thread.join(); // 等待线程结束
	return 0;
}

5.总结

本文主要介绍了thread类，以及他的成员函数join()、detach()、joinable()函数，以及用不同的可调用对象开启一个线程。