1. thread类的简单介绍

在C++11之前，涉及到多线程问题，都是和平台相关的，比如windows和linux下各有自己的接口，这使得代码的可移植性比较差。C++11中最重要的特性就是对线程进行支持了，使得C++在并行编程时不需要依赖第三方库，而且在原子操作中还引入了原子类的概念。要使用标准库中的线程，必须包含< thread >头文件。
C++11中线程类

还有一些和线程有关的锁、条件变量、原子操作等。

C++11线程库本质是对不同平台的线程库进行封装。

先看看线程相关主要的接口

函数名	功能
thread()	构造一个线程对象，没有关联任何线程函数，即没有启动任何线程
thread(fn,args1, args2,…)	构造一个线程对象，并关联线程函数fn，args1，args2，…为线程函数的参数
get_id()	获取线程id
jionable()	线程是否还在执行，joinable代表的是一个正在执行中的线程。
jion()	该函数调用后会阻塞住线程，当该线程结束后，主线程继续执行
detach()	在创建线程对象后马上调用，用于把被创建线程与线程对象分离开，分离的线程变为后台线程，创建的线程的"死活"就与主线程无关

线程不允许拷贝构造，但支持移动构造。

也不允许赋值重载。但支持移动赋值。

注意：
1.线程是操作系统中的一个概念，线程对象可以关联一个线程，用来控制线程以及获取线程的状态。
2.当创建一个线程对象后，没有提供线程函数，该对象实际没有对应任何线程。

int main()
{
	thread t1;
	return 0;
}

3.当创建一个线程对象后，并且给线程关联线程函数，该线程就被启动，与主线程一起运行。
线程函数一般情况下可按照以下三种方式提供：

• 函数指针
• lambda表达式
• 函数对象

void ThreadFunc(int a)
{
	cout << "Thread1" << a << endl;
}

class TF
{
public:
	void operator()()
	{
		cout << "Thread3" << endl;
	}
};

int main()
{
	// 线程函数为函数指针
	thread t1(ThreadFunc, 10);

	// 线程函数为lambda表达式
	thread t2([] {cout << "Thread2" << endl; });

	// 线程函数为函数对象
	TF tf;
	thread t3(tf);

	t1.join();
	t2.join();
	t3.join();
	cout << "Main thread!" << endl;
	return 0;
}

还有在前面说过的创建线程池

int main()
{
	int n,m;
	cin>>n>>m;

	vector<thread> v;
	v.resize(n);//调用thread默认构造函数,无参的

	//必须加引用,因为不加引用就是拷贝,而thread没有拷贝构造,只有移动构造
	for (auto& t : v)
	{
		//移动赋值
		t = thread([m] {
				for (size_t i = 0; i < m; ++i)
				{
					//这里想要把线程id打印出来,但是需要对象来调get_id();
					//但这里没有对象怎么办调用呢?
					//使用this_thread::get_id()
					cout << this_thread::get_id() << ":" << i << endl;
				}
			});
	}

	//这里主线程要join，不然主线程结束了进程就结束了
	for (auto& t : v)
	{
		//阻塞等待
		t.join();
	}

	return 0;
}

有好多东西是在线程的执行函数里面需要用到的，但是没有线程对象可以用，因此把这写东西写成全局的。所以把一些线程用到的公共的类放到这个命名空间里面

yield：线程时间片还没有用完，但让出时间片让其他线程先跑
sleep_until：休眠到一个时间点
sleep_for：休眠一个时间段，如休眠3秒，5秒

4.可以通过jionable()函数判断线程是否是有效的，如果是以下任意情况，则线程无效

• 采用无参构造函数构造的线程对象
• 线程对象的状态已经转移给其他线程对象
• 线程已经调用jion或者detach结束

问：
1.进程和线程的区别？
linux有说明

2.多进程域多线程的区别？
linux有说明，这里简单说一下
一个进程出现问题不会影响其他进程，而一个线程出现问题因为线程就是在进程的地址空间运行的它出问题肯定就是进程出现了问题所以会导致整个进程退出。

3.并发与并行的区别？
并行与并发是计算机领域中两个重要的概念，它们描述了多任务处理的不同方式。
并行是指同时执行多个任务，每个任务在不同的处理器上独立运行。在并行计算中，多个任务可以同时进行，从而提高系统的整体处理能力。并行计算通常需要具备多个处理器或者多核处理器来实现。
并发是指多个任务在同一时间段内交替执行，通过时间片轮转等方式实现任务的切换。在并发计算中，多个任务共享同一个处理器，通过快速切换任务的执行来实现多任务的效果。并发计算通常适用于单个处理器或者单核处理器的情况。
简而言之，区别在于并行是同时执行多个任务，而并发是交替执行多个任务。

2.线程函数参数

线程函数的参数是以值拷贝的方式拷贝到线程栈空间中的，因此：即使线程参数为引用类型，在线程中修改后也不能修改外部实参，因为其实际引用的是线程栈中的拷贝，而不是外部实参。

void ThreadFunc1(int& x)
{
	x += 10;
}

void ThreadFunc2(int* x)
{
	*x += 10;
}

int main()
{
	int a = 10;
	// 在线程函数中对a修改，不会影响外部实参，因为：线程函数参数虽然是引用方式，但其实际引用的是线程栈中的拷贝
	thread t1(ThreadFunc1, a);
	t1.join();
	cout << a << endl;

	// 如果想要通过形参改变外部实参时，必须借助std::ref()函数
	thread t2(ThreadFunc1, std::ref(a));
	t2.join();
	cout << a << endl;

	// 地址的拷贝
	thread t3(ThreadFunc2, &a);
	t3.join();
	cout << a << endl;

	return 0;
}

注意：如果是类成员函数作为线程参数时，必须将this作为线程函数参数

3.原子性操作库(atomic)

多线程最主要的问题是共享数据带来的问题(即线程安全)。如果共享数据都是只读的，那么没问题，因为只读操作不会影响到数据，更不会涉及对数据的修改，所以所有线程都会获得同样的数据。但是，当一个或多个线程要修改共享数据时，就会产生很多潜在的麻烦。比如：

两个线程对共享变量进行++，可能会出现线程不安全的问题。

int val = 0;

void Func1(int n)
{
	for (size_t i = 0; i < n; ++i)
	{
		++val;
	}
}

void Func2(int n)
{
	for (size_t i = 0; i < n; ++i)
	{
		++val;
	}
}

int main()
{
	thread t1(Func1, 10000);
	thread t2(Func2, 20000);

	t1.join();
	t2.join();

	cout << val << endl;

	return 0;
}

比较好的解决方法就是加锁。

#include<mutex>

mutex mtx;
int val = 0;

void Func1(int n)
{
	for (size_t i = 0; i < n; ++i)
	{
		mtx.lock();
		++val;
		mtx.unlock();
	}
}

void Func2(int n)
{
	for (size_t i = 0; i < n; ++i)
	{
		mtx.lock();
		++val;
		mtx.unlock();
	}
}

int main()
{
	thread t1(Func1, 10000);
	thread t2(Func2, 20000);


	t1.join();
	t2.join();

	cout << val << endl;

	return 0;
}

加锁之后就是线程安全的了。

这把锁加在里面好，还是外面好呢？这个等会在说，先看下面的。两个线程能不能同时执行同一个函数，会不会出现其他问题呢？其实学过linux线程都知道是可以的。但为什么呢？

#include<mutex>

mutex mtx;
int val = 0;

void Func1(int n)
{
	for (size_t i = 0; i < n; ++i)
	{
		mtx.lock();
		++val;
		mtx.unlock();
	}
}

int main()
{
	thread t1(Func1, 10000);
	thread t2(Func1, 20000);

	t1.join();
	t2.join();

	cout << val << endl;

	return 0;
}

为什么两个线程可以执行同一个函数？
因为这个函数编译好是放在代码段的，两个线程都可以去代码段取这个函数。其次最重要的是每个线程都有独立的栈结构，两个线程调用函数要建立自己的栈帧，互不影响。你传的参数放在你的栈帧里，它传的参数放在它的栈帧里。

回到上一个问题，这个锁到底加在外面好还是里面好呢？
对于在锁里的语句短且简单，建议把锁加载外面，因为锁频繁切换也要消耗资源。

void Func1(int n)
{
	mtx.lock();
	for (size_t i = 0; i < n; ++i)
	{
		++val;
	}
	mtx.unlock();
}

另一种方式：原子操作
原理很简单，让++变成原子操作。
原子操作都是由CAS提供的，系统一般会提供CAS相关的接口。
CAS本质就是compare and swap

下面具体看一下原理，看如何是++变成原子操作的。

这里即使是同时++也只有一个线程能够写回去。
对这里有兴趣的可以看看陈皓大佬的这篇文章。
无锁队列的实现

C++线程库提供atomic就是对CAS以及刚才一系列东西的封装。

就比如最下面的对++、- -、与、或、异或等这些操作都是原子的。

在C++11中，程序员不需要对原子类型变量进行加锁解锁操作，线程能够对原子类型变量互斥的访问。
更为普遍的，程序员可以使用atomic类模板，定义出需要的任意原子类型。

atmoic<T> t;    // 声明一个类型为T的原子类型变量t

注意：原子类型通常属于"资源型"数据，多个线程只能访问单个原子类型的拷贝，因此在C++11中，原子类型只能从其模板参数中进行构造，不允许原子类型进行拷贝构造、移动构造以及operator=等，为了防止意外，标准库已经将atmoic模板类中的拷贝构造、移动构造、赋值运算符重载默认删除掉了。

#include <atomic>
int main()
{
	atomic<int> a1(0);
	//atomic<int> a2(a1);   // 编译失败
	atomic<int> a2(0);
	//a2 = a1;               // 编译失败
	return 0;
}

把上面代码改成这种方式，不仅不需要加锁，而且也是并行运行的。

#include<atomic>

atomic<int> aval = 0;

void Func1(int n)
{	
	for (size_t i = 0; i < n; ++i)
	{
		++aval;
	}

}

int main()
{
	thread t1(Func1, 10000);
	thread t2(Func1, 20000);


	t1.join();
	t2.join();

	cout << aval << endl;

	return 0;
}

刚才这种写法还有一些弊端，实际写用不太建议写成全局的。
但是不用全局的也就不是共享资源了，线程执行的函数又拿不到就不涉及线程安全的问题了，这里就体现C++11这里用lambda更好一些。给了lambda就可以定义局部的。因为lambda可以捕捉局部的变量，就可以避免用全局的这样方式。

int main()
{
	atomic<int> aval = 0;
	auto func = [&aval](int n) {
		for (size_t i = 0; i < n; ++i)
		{
			++aval;
		}
	};

	thread t1(func, 10000);
	thread t2(func, 20000);

	t1.join();
	t2.join();

	cout << aval << endl;

	return 0;
}

4.mutex的种类

在C++11中，Mutex总共包了四个互斥量的种类

1.mutex

C++11提供的最基本的互斥量，该类的对象之间不能拷贝，也不能进行移动。mutex最常用的三个函数：

函数名	函数功能
lock()	上锁：锁住互斥量
unlock()	解锁：释放对互斥量的所有权
try_lock()	尝试锁住互斥量，如果互斥量被其他线程占有，则当前线程也不会被阻塞

注意，线程函数调用lock()时，可能会发生以下三种情况：

• 如果该互斥量当前没有被锁住，则调用线程将该互斥量锁住，直到调用 unlock之前，该线程一直拥有该锁
• 如果当前互斥量被其他线程锁住，则当前的调用线程被阻塞住
• 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)

线程函数调用try_lock()时，可能会发生以下三种情况：

• 如果当前互斥量没有被其他线程占有，则该线程锁住互斥量，直到该线程调用 unlock 释放互斥量
• 如果当前互斥量被其他线程锁住，则当前调用线程返回 false，而并不会被阻塞掉
• 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)

注意：
互斥锁不能在递归里面用的，递归里面玩互斥锁就可能死锁

2. recursive_mutex 递归互斥锁

其允许同一个线程对互斥量多次上锁（即递归上锁），来获得对互斥量对象的多层所有权，释放互斥量时需要调用与该锁层次深度相同次数的unlock()，除此之外，recursive_mutex 的特性和mutex 大致相同。

原理：注意并不是解锁之后再加锁，万一有其他线程在等待，解锁有可能其他线程抢到锁了然后运行，但是并不希望是这样。锁的时候知道是那个线程获得这个锁的，知道这个线程id，等在递归时候看新来的线程跟获取锁的id是不是同一个，如果是同一个，就不在加锁直接走就可以了。

3.timed_mutex

比mutex多了两个成员函数，try_lock_for()，try_lock_until() 。

• try_lock_for()
  接受一个时间范围，表示在这一段时间范围之内线程如果没有获得锁则被阻塞住（与mutex 的 try_lock() 不同，try_lock 如果被调用时没有获得锁则直接返回false），如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false。

• try_lock_until()
  接受一个时间点作为参数，在指定时间点未到来之前线程如果没有获得锁则被阻塞住，如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false。

控制时间通常用下面这个类

int main()
{
	atomic<int> aval = 0;
	auto func = [&aval](int n) {
		for (size_t i = 0; i < n; ++i)
		{
			++aval;
			this_thread::sleep_for(chrono::milliseconds(2000));
			cout << aval << endl;
		}
	};

	thread t1(func, 10000);
	thread t2(func, 20000);


	t1.join();
	t2.join();

	cout << aval << endl;

	return 0;
}

4.recursive_timed_mutex
这个就不再细说。

5. RAII风格加锁解锁

5.1Lock_guard

RAII风格加锁解锁：
构造时加锁，析构时解锁。

int main()
{
	atomic<int> aval = 0;
	mutex mtx;
	auto func = [&aval,&mtx](int n) {
		for (size_t i = 0; i < n; ++i)
		{

			{
				//只在这个作用域加锁出了作用域就自动解锁
				//可以收到控制加锁范围
				lock_guard<mutex> lock(mtx);
				cout <<this_thread::get_id()<<"->"<< aval << endl;
			}
			
			++aval;
		}
	};

	thread t1(func, 10000);
	thread t2(func, 20000);


	t1.join();
	t2.join();

	cout << aval << endl;

	return 0;
}

lock_guard的缺陷：太单一，用户没有办法对该锁进行控制，因此C++11又提供了unique_lock。

5.2unique_lock

与lock_gard类似，unique_lock类模板也是采用RAII的方式对锁进行了封装，并且也是以独占所有权的方式管理mutex对象的上锁和解锁操作，即其对象之间不能发生拷贝。在构造(或移动(move)赋值)时，unique_lock 对象需要传递一个 Mutex 对象作为它的参数，新创建的unique_lock 对象负责传入的 Mutex 对象的上锁和解锁操作。使用以上类型互斥量实例化
unique_lock的对象时，自动调用构造函数上锁，unique_lock对象销毁时自动调用析构函数解锁，可以很方便的防止死锁问题。

与lock_guard不同的是，unique_lock更加的灵活，提供了更多的成员函数：

• 上锁/解锁操作：lock、try_lock、try_lock_for、try_lock_until和unlock
• 修改操作：移动赋值、交换(swap：与另一个unique_lock对象互换所管理的互斥量所有权)、释放(release：返回它所管理的互斥量对象的指针，并释放所有权)
• 获取属性：owns_lock(返回当前对象是否上了锁)、operator bool()(与owns_lock()的功能相同)、mutex(返回当前unique_lock所管理的互斥量的指针)。

6.condition_variable

写一个支持两个线程交替打印，一个打印奇数，一个打印偶数

// 支持两个线程交替打印，t1一个打印奇数，t2一个打印偶数,打印到100
int main()
{	
	int i = 0;
	thread t1([&] {
		while (i < 100)
		{
			if (i % 2)
			{
				cout << this_thread::get_id() << "->" << i << endl;
				++i;
			}
		}
	});

	thread t2([&] {
		while (i < 100)
		{
			if (i % 2 == 0)
			{
				cout << this_thread::get_id() << "->" << i << endl;
				++i;
			}
		}
	});
	
	t1.join();
	t2.join();
	
	return 0;
}

这个程序有些问题，首先没有100。证明有个程序少跑了一次。可能i是99，t1 if判断之后把i加到100，然后t2在上去while判断不符合，所有就没有打印出100。

那把t2线程，while判断改成<=100，能不能解决问题？
是可以初步解决问题的。

int main()
{
	
	int i = 0;
	thread t1([&] {
		while (i < 100)
		{
			if (i % 2)
			{
				cout << this_thread::get_id() << "->" << i << endl;
				++i;
			}
		}
	});

	thread t2([&] {
		while (i <= 100)
		{
			if (i % 2 == 0)
			{
				cout << this_thread::get_id() << "->" << i << endl;
				++i;
			}
		}
	});
	

	t1.join();
	t2.join();
	
	return 0;
}

这里真正的问题是，效率不好。有这样的可能性。i为0 然后打印i在++，在然后t2时间片到了就切出去了，但t1线程时间片没有到会一直在转，因为i是1然后%2打印i，然后i++，i变成2了。然后i一直是2一直在转，不断的白判断浪费cpu资源。直到t2回来。

这里能不能你完了通知我，我完了通知你。

加锁可不可以？

int main()
{
	int i = 0;
	mutex mtx;
	thread t1([&] {
		while (i < 100)
		{
			mtx.lock();
			cout << this_thread::get_id() << "->" << i << endl;
			++i;
			mtx.unlock();
		}
		});

	thread t2([&] {
		while (i < 100)
		{
			mtx.lock();
			cout << this_thread::get_id() << "->" << i << endl;
			++i;
			mtx.unlock();		
		}
		});

	t1.join();
	t2.join();

	return 0;
}

可以看到光加锁，并不能实现交替打印。

原因可能是其中一个线程竞争能力太强了，解锁之后又成功加锁，导致另一个线程一直在阻塞等待，所以导致这个情况。

这里最好的方式就是使用环境变量。


wait就是等待，notify就是通知。
条件变量并不是线程安全的，需要和锁配合使用。
注意是unique_lock RAII风格的锁。

这个wait就和linux说过的一样，

当线程阻塞了就会自动释放这个锁让其他线程去竞争这把锁，一旦被唤醒就要重新申请到这个锁，从这个wait返回就一定是拿到锁往下走。

#include<condition_variable>

int main()
{
	int i = 0;
	mutex mtx;
	condition_variable cv;
	//奇数
	thread t1([&] {
		while (i < 100)
		{
			unique_lock<mutex> lock(mtx);

			while (i % 2 == 0)
			{
				cv.wait(lock);
			}
			cout << "t1: " << this_thread::get_id() << "->" << i << endl;
			++i;
			cv.notify_one();

		}
		});

	//偶数
	thread t2([&] {
		while (i <= 100)
		{
			unique_lock<mutex> lock(mtx);
			while (i % 2)
			{
				cv.wait(lock);
			}
			cout << "t2: " << this_thread::get_id() << "->" << i << endl;
			++i;
			cv.notify_one();
	
		}
		});

	t1.join();
	t2.join();

	return 0;
}

int main()
{
	int i = 0;
	mutex mtx;
	condition_variable cv;
	bool flag = true;
	//奇数 -- flag = true
	thread t1([&] {
		while (i < 100)
		{
			unique_lock<mutex> lock(mtx);
			while (flag == true)
			{
				cv.wait(lock);//阻塞
			}
			cout << "t1: " << this_thread::get_id() << "->" << i << endl;
			++i;
			flag = true;
			cv.notify_one();

		}
		});

	//偶数 -- flag = true
	thread t2([&] {
		while (i <= 100)
		{
			unique_lock<mutex> lock(mtx);
			while (flag == false)
			{
				cv.wait(lock);
			}
			cout << "t2: " << this_thread::get_id() << "->" << i << endl;
			++i;
			flag = false;
			cv.notify_one();

		}
		});

	t1.join();
	t2.join();

	return 0;
}

第二种wait方式

当pred返回false时才会阻塞。返回true不会阻塞。

int main()
{
	int i = 0;
	mutex mtx;
	condition_variable cv;
	//奇数 -- flag = true
	thread t1([&] {
		while (i < 100)
		{
			unique_lock<mutex> lock(mtx);
			cv.wait(lock, [&] {return i % 2; });//返回false被阻塞,true不被阻塞
			cout << "t1: " << this_thread::get_id() << "->" << i << endl;
			++i;
			cv.notify_one();
		}
		});

	//偶数 -- flag = true
	thread t2([&] {
		while (i <= 100)
		{
			unique_lock<mutex> lock(mtx);
			cv.wait(lock, [&] {return !(i % 2); });//返回false被阻塞,true不被阻塞
			cout << "t2: " << this_thread::get_id() << "->" << i << endl;
			++i;
			cv.notify_one();
		}
		});

	t1.join();
	t2.join();

	return 0;
}