【C++】C++11【下】lambda表达式|thread线程库

目录

1、lambda表达式

1.1 lambda表达式的引入

 1.2 lambda表达式的语法

1.3 lambda表达式的原理

 2、线程库

2.1thread类的介绍

2.2 线程函数参数

2.3 原子性操作库(atomic)

2.4 使用场景

应用场景1：

应用场景2:

应用场景3：

应用场景4：

---

本文为C++【下】

C++11【上】链接：【C++】C++11【上】列表初始化|声明|新容器|右值引用|完美转发|新的类功能-CSDN博客

1、lambda表达式

1.1 lambda表达式的引入

在C++98中，如果想要对一个数据集合中的元素进行排序，可利用sort

下面利用sort的使用来引出lambda表达式，因为sort是个函数模板，故第三个参数可以接受函数指针，函数对象（仿函数），lambda表达式，这里先利用前两个来实现

#include <algorithm>
#include <functional>//当需要用到仿函数(函数对象)时用，但你不写也能编译运行成功

template<class T>
struct Greater
{
	bool operator()(const T& x1, const T& x2)
	{
		return x1 > x2;
	}
};

bool g2(const int& x1, const int& x2)
{
	return x1 > x2;
}
int main()
{
	int array[] = { 4,1,8,5,3,7,0,9,2,6 };
	// 默认按照小于比较，排出来结果是升序
	std::sort(array, array + sizeof(array) / sizeof(array[0]));
	// 如果需要降序，需要改变元素的比较规则
	//std::sort(array, array + sizeof(array) / sizeof(array[0]), Greater<int>());

	Greater<int> g1;
	g1(1, 2);	//g1是一个对象，调用它的operator()实现的
	g2(1, 2);	//g2是一个函数指针，调用它指向的函数
	
	//他们是完全不同的对象，但用起来是一样的，均可排序
	std::sort(array, array + sizeof(array) / sizeof(array[0]), g1);
	std::sort(array, array + sizeof(array) / sizeof(array[0]), g2);

	return 0;
}

如果待排序元素为自定义类型，需要用户定义排序时的比较规则：  

struct Goods
{
	string _name;  // 名字
	double _price; // 价格
	int _evaluate; // 评价
	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};
struct ComparePriceLess
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price < gr._price;
	}
};
struct ComparePriceGreater
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price > gr._price;
	}
};
int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
   3 }, { "菠萝", 1.5, 4 } };

	sort(v.begin(), v.end(), ComparePriceLess());
	sort(v.begin(), v.end(), ComparePriceGreater());
}

随着 C++ 语法的发展， 人们觉得上面的写法太复杂了，每次为了实现一个 algorithm 算法， 都要重新去写一个类（仿函数或函数），如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名， 一般需要根据功能来命名（你瞎命名别人很难看懂） 。因此，在 C++11 语法中出现了 Lambda 表达式。

---

 1.2 lambda表达式的语法

lambda表达式书写格式：

[capture-list] (parameters) mutable -> return-type { statement }

1. lambda表达式各部分说明:

①、[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来

判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。

②、(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以

连同()一起省略

③、mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量

性。使用该修饰符时，参数列表不可省略(即使参数为空)。

④、->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回

值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。

⑤、{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获

到的变量。

注意：

在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为

空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情

int main()
{
	// 最简单的lambda表达式, 该lambda表达式没有任何意义
	[] {};

	// 省略参数列表和返回值类型，返回值类型由编译器推导为int
	int a = 3, b = 4;
	[=] {return a + 3; };

	// 省略了返回值类型，无返回值类型
	auto fun1 = [&](int c) {b = a + c; };
	fun1(10);
	cout << a << " " << b << endl; //3 13

	// 各部分都很完善的lambda函数
	auto fun2 = [=, &b](int c)->int {return b += a + c; };
	cout << fun2(10) << endl; //26

	// 捕捉x
	int x = 10;
	auto add_x = [x](int a) mutable { x *= 2; return a + x; };
	cout << add_x(10) << endl; //30
	return 0;
}

2. 捕获列表说明:

捕捉列表描述了上下文中哪些数据可以被 lambda 使用 ，以及 使用的方式传值还是传引用 。

【捕捉列表就是捕捉跟我同一个作用域的对象】

传值捕捉：[a]捕捉a [a,b]捕捉a，b  [=]捕捉同一作用域中的所有对象

但传值捕捉的对象是不能被改变的，加上mutable就可以改变
传引用捕捉：[&a]捕捉a [&a,&b]捕捉a，b  [&]捕捉同一作用域中的所有对象

• [var]：   表示值传递方式捕捉变量var
• [=]：      表示值传递方式捕获所有父作用域中的变量(包括this)
• [&var]：表示引用传递捕捉变量var
• [&]：     表示引用传递捕捉所有父作用域中的变量(包括this)
• [this]：  表示值传递方式捕捉当前的this指针(其实=和&就已经包含this指针了)

下面利用lambda表达式实现相加和交换两数操作，了解lambda表达式的使用

int add1(int a, int b)
{
	return a + b;
}

int main()
{
	int a = 0, b = 1;
	//实现一个a+b的lambda表达式
	auto add1 = [](int x1, int x2)->int{return x1 + x2;};//返回值可不写，编译器会自动推(但不建议)
	cout << add1(a, b) << endl;
	cout << ::add1(a, b) << endl;//调用全局域的add1，即主函数之外的

	//auto add1 = [](int x1, int x2)->int {return x1 + x2 + a; };//没捕捉a导致无法使用
	auto add1 = [a](int x1, int x2)->int {return x1 + x2 + a; };//捕捉a后可以正常使用
	auto add1 = [a,b]()->int {return a + b; };//捕捉a，b，只用于a + b

	//实现a和b交换
	auto swap1 = [](int& x, int& y)
	{	int z = x;
		x = y;
		y = z; 
	};
	swap(a, b);

	//不正确的用法，即使加上mutable可以修改传值捕捉了，但传值捕捉的
	//是a和b的拷贝，只是把a和b的拷贝交换了而已，所以这里是没意义的
	auto swapab = [a, b]()mutable
	{
		int c = a;
		a = b;
		b = c;
	};
	swapab();

	return 0;
}

注意：

a. 父作用域指包含 lambda 函数的语句块

b. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割 。

比如：

[=, &a, &b] ：以引用传递的方式捕捉变量 a 和 b ，值传递方式捕捉其他所有变量

[& ， a, this] ：值传递方式捕捉变量 a 和 this ，引用方式捕捉其他变量

c. 捕捉列表不允许变量重复传递，否则就会导致编译错误 。

比如： [=, a] ： = 已经以值传递方式捕捉了所有变量，捕捉 a 重复

d. 在块作用域以外的 lambda 函数捕捉列表必须为空 。

e. 在块作用域中的 lambda 函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者

非局部变量都会导致编译报错。

f. lambda 表达式之间不能相互赋值 ，即使看起来类型相同

void (*PF)();
int main()
{
	auto f1 = [] {cout << "hello world" << endl; };
	auto f2 = [] {cout << "hello world" << endl; };
	// 此处先不解释原因，等lambda表达式底层实现原理看完后，大家就清楚了
	//f1 = f2;   // 编译失败--->提示找不到operator=()
	// 允许使用一个lambda表达式拷贝构造一个新的副本
	auto f3(f2);
	f3();
	// 可以将lambda表达式赋值给相同类型的函数指针
	PF = f2;
	PF();
	return 0;
}

3.使用场景:

struct Goods
{
	string _name;	// 名字
	double _price; // 价格
	int _evaluate; // 评价
	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};

int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
   3 }, { "菠萝", 1.5, 4 } };
	//因为sort是个函数模板，故第三个参数可以传仿函数，函数指针和lambda表达式
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		return g1._price < g2._price; });
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		return g1._price > g2._price; });
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		return g1._evaluate < g2._evaluate; });
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		return g1._evaluate > g2._evaluate; });
	
	//一般我们不会像下面这么用，我们一般都是构造lambda表达式的匿名对象
	/*auto price_greater = [](const Goods& g1, const Goods& g2)->bool {return g1._price <
		g2._price; };
	sort(v.begin(), v.end(), price_greater);*/
}

---

1.3 lambda表达式的原理

先看以下用仿函数和lambda表达式实现的代码：

class Rate
{
public:
	Rate(double rate) : _rate(rate)
	{}
	double operator()(double money, int year)
	{
		return money * _rate * year;
	}
private:
	double _rate;
};
int main()
{
	// 函数对象
	double rate = 0.49;
	Rate r1(rate);
	r1(10000, 2);//仿函数
	// lambda
	auto r2 = [=](double monty, int year)->double {return monty * rate * year;
		};
	r2(10000, 2);//lambda表达式
	return 0;
}

从使用方式上来看，函数对象与 lambda表达式完全一样。函数对象将 rate 作为其成员变量，在定义对象时给出初始值即可， lambda表达式通过捕获列表可以直接将该变量捕获到。

实际在底层编译器对于 lambda 表达式的处理方式，完全就是按照函数对象的方式处理的，即：如

果定义了一个 lambda 表达式，编译器会自动生成一个类，在该类中重载了 operator() 。

int main()
{
	int a = 1, b = 2;
	// 对象 = 对象(编译器生成的lambda_uuid仿函数的对象)
	auto add = [](int x, int y)->int {return x + y; };

	add(a,b); //call lambda_uuid仿函数的operator()

	//底层还是靠仿函数来实现，也就是说你定义了一个lambda表达式，实际上
	//编译器会全局域生成一个叫lambda_uuid类，仿函数的operator()的参数和实现
	//就是我们写的lambda表达式的参数和实现
	
	//仿函数和lambda表达式的关系如同迭代器和范围for的关系，也就是lambda表达式存在即合理

	return 0;
}

---

 2、线程库

2.1thread类的介绍

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

C++11 线程库
windows 自己的一套API         如：CreateThread
Linux   使用posix的pthread  如：pthread_create
C++98中，若你想写多线程的程序，既想在windows下跑，也想在Linux下跑，怎么办？
用条件编译
#ifdef _WIN32
    CreateThread(...)
#else
    pthread_create(...)
#endif

C++11 线程库
特点：跨平台、面向对象封装的类（每个线程是一个类对象）
实现原理：封装库时使用了条件编译，也就是他的底层还是分别调用了不同平台的线程API

扩展：C++缺点之一：有用的东西更新的太慢了，比如线程库C++11（2011）才更新的，且到现在也没有更新一个官方的封装好的靠谱网络库，其次一堆使用意义不大的语法一堆，学习成本高

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

注意：

1. 线程是操作系统中的一个概念， 线程对象可以关联一个线程，用来控制线程以及获取线程的

状态 。

2. 当创建一个线程对象后，没有提供线程函数，该对象实际没有对应任何线程。

#include <thread>
int main()
{
 std::thread t1;
 cout << t1.get_id() << endl;
 return 0;
}

get_id()的返回值类型为id 类型， id 类型实际为 std::thread 命名空间下封装的一个类，该类中

包含了一个结构体：

// vs下查看
typedef struct
{ /* thread identifier for Win32 */
 void *_Hnd; /* Win32 HANDLE */
 unsigned int _Id;
} _Thrd_imp_t;

3. 当创建一个线程对象后，并且给线程关联线程函数，该线程就被启动，与主线程一起运行。

线程函数一般情况下可按照以下三种方式提供：

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

#include <iostream>
using namespace std;
#include <thread>
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;
}

4. thread 类是防拷贝的，不允许拷贝构造以及赋值，但是可以移动构造和移动赋值，即将一个

线程对象关联线程的状态转移给其他线程对象，转移期间不意向线程的执行。

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

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

---

2.2 线程函数参数

线程函数的参数是以值拷贝的方式拷贝到线程栈空间中的 ，因此：即使线程参数为引用类型，在

线程中修改后也不能修改外部实参，因为 其实际引用的是线程栈中的拷贝，而不是外部实参 。

#include <thread>
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 作为线程函数参数。

---

2.3 原子性操作库(atomic)

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

#include <thread>
unsigned long sum = 0L;

void fun(size_t num)
{
	for (size_t i = 0; i < num; ++i)
		sum++;
}
int main()
{
	cout << "Before joining,sum = " << sum << std::endl;
	thread t1(fun, 10000000);
	thread t2(fun, 10000000);
	t1.join();
	t2.join();
	cout << "After joining,sum = " << sum << std::endl;//每次打印的结果都不一样
	return 0;
}

C++98 中传统的解决方式：可以对共享修改的数据可以加锁保护。

#include <thread>
#include <mutex>
std::mutex m;
unsigned long sum = 0L;
void fun(size_t num)
{
	for (size_t i = 0; i < num; ++i)
	{
		m.lock();
		sum++;
		m.unlock();
	}
}
int main()
{
	cout << "Before joining,sum = " << sum << std::endl;
	thread t1(fun, 10000000);
	thread t2(fun, 10000000);
	t1.join();
	t2.join();
	cout << "After joining,sum = " << sum << std::endl;//每次打印结果均正确
	return 0;
}

虽然加锁可以解决，但是加锁有一个缺陷就是：只要一个线程在对 sum++ 时，其他线程就会被阻

塞，会影响程序运行的效率，而且锁如果控制不好，还容易造成死锁。 因此C++11中引入了原子操作。

问：锁的串行效率高还是并行效率高？

答：串行效率高

mutex mtx;
int x = 0;

//两个线程一起对x加n次
void Add(int n)
{	
	//串行：一个线程跑完了，另一个线程接着跑
	mtx.lock();
	for (int i = 0; i < n; ++i)
	{
		++x;
	}
	mtx.unlock();

	//并行：两个线程同时跑
	/*for (int i = 0; i < n; ++i)
	{
		mtx.lock();// 比如t2刚切出去，t1就解锁了。++后马上又把t2切回来
		++x;
		mtx.unlock();
	}*/

	//实际上串行更快。为什么？因为这里锁的力度太小了，时间都花到切换上下文了。
}

原子操作：即不可被中断的一个或一系列操作， C++11引入 的原子操作类型，使得线程间数据的同步变得非常高效。

注意：需要使用以上原子操作变量时，必须添加头文件

 在 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;
}

---

2.4 使用场景

应用场景1：

两个线程一起对x加n次：thread各配合函数指针、仿函数、lambda表达式使用

①、函数指针

atomic<int> x = 0; //支持整形/浮点的原子++，--
//扩展学习：atomic支持CAS->无锁编程

//两个线程一起对x加n次
void Add(int n)
{
	for (int i = 0; i < n; ++i)
	{
		++x;
	}
}

int main()
{
 
 //利用函数指针配合thread
	thread t1(Add, 1000000);//加锁之后每次计算的出的数据就准确了
	thread t2(Add, 1000000);


	//要在主线程结束前对两个线程join一下才行
	t1.join();
	t2.join();

	cout << x << endl;

	return 0;
}

②、仿函数

atomic<int> x = 0;
struct Add
{
	int operator()(int n)
	{
		for (int i = 0; i < n; ++i)
		{
			++x;
		}

		return x;
	}
};
int main()
{
	Add add;

	//利用仿函数对象配合thread
	thread t1(add, 1000000);
	thread t2(add, 1000000);//也可以写为Add()，即用匿名对象

	//要在join前获取线程id
	cout << t1.get_id() << endl;//每次获取到的ID不一
	cout << t2.get_id() << endl;//每次获取到的ID不一

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

	cout << x << endl;//2000000

	return 0;
}

③、lambda表达式

int main()
{
	atomic<int> x = 0;

	auto add = [&x](int n) {
		for (int i = 0; i < n; ++i)
		{
			++x;
		}
		};

	thread t1(add, 1000000);
	thread t2(add, 1000000);//也可以写为Add()，即用匿名对象

	//要在join前获取线程id
	cout << t1.get_id() << endl;//每次获取的ID不一
	cout << t2.get_id() << endl;//每次获取的ID不一

	t1.join();
	t2.join();
	
	cout << x << endl;//2000000

	return 0;
}

---

应用场景2:

m个线程对x加n次

int main()
{
	atomic<int> x = 0;
	//m个线程对x加n次
	int m, n;
	cin >> m >> n;
	vector<thread> vthreads;
	for (int i = 0; i < m; ++i)
	{
		vthreads.push_back(thread([&x](int count) {
			for (int i = 0; i < count; ++i)
			{
				++x;
			}
		}, n));
	}

	for (auto& t : vthreads)
	{
		cout << t.get_id() << "join" << endl;
		t.join();
	}

	cout << x << endl;

	return 0;
}

//写法二
int main()
{
	atomic<int> x = 0;
	//m个线程对x加n次
	int m, n;
	cin >> m >> n;

	//thread支持移动赋值和移动拷贝，不支持深拷贝的拷贝构造和拷贝赋值
	vector<thread> vthreads(m);
	for (int i = 0; i < m; ++i)
	{
		//移动赋值【thread构造的是匿名对象，返回右值】
		vthreads[i] = thread([&x](int count) {
			for (int i = 0; i < count; ++i)
			{
				++x;
			}
			}, n);
	}

	for (auto& t : vthreads)
	{
		cout << t.get_id() << "join" << endl;
		t.join();
	}

	cout << x << endl;

	return 0;
}

---

应用场景3：

使用两个线程打印0~n之间的数，一个线程打印奇数，一个线程打印偶数，要求依次打印。

//以下代码存在一个问题：竞争终端,每次结果都不一样，且都不对
int main()
{
	int n = 100;
	thread t1([n]()
	{
		for (int i = 0; i < n; ++i)
		{
			//偶数
			if (i % 2 == 0)
				cout << this_thread::get_id() << ":" << i << endl;
		}
	});

	thread t2([n]()
		{
			for (int i = 0; i < n; ++i)
			{
				//奇数
				if (i % 2)
					cout << this_thread::get_id() << ":" << i << endl;//利用this_thread可以不需要线程对象就获取到id
			}
		});

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

	return 0;
}

​​​​​​改善后:

#include<mutex>
#include<condition_variable>

//偶数和奇数依次打印的过程类似于生产者消费者模型
//互斥锁和条件变量同时使用
int main()
{
	int n = 100;
	mutex mtx1, mtx2;
	condition_variable cv1, cv2;//条件变量（一个是不行的，要让偶数先走），必须配合锁用


	thread t1([&]()
		{
			for (int i = 0; i < n; i+=2)
			{	if (i != 0)
					cv1.wait(unique_lock<mutex>(mtx1));

				//偶数
				cout << this_thread::get_id() << ":" << i << endl;

				cv2.notify_one(); //t1打印偶数以后，通知t2
			}
		});

	thread t2([&]()
		{
			for (int i = 0; i < n; i+=2)
			{
				cv2.wait(unique_lock<mutex>(mtx2));//要传互斥锁来保护条件变量
				//奇数
				cout << this_thread::get_id() << ":" << i << endl;//利用this_thread可以不需要线程对象就获取到id
				cv1.notify_one(); //t2
			}
		});

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

	return 0;
}

//法二
int main()
{
	int n = 100;
	mutex mtx1, mtx2;
	condition_variable cv1, cv2;//条件变量（一个是不行的，要让偶数先走），必须配合锁用


	thread t1([&]()
		{
			for (int i = 0; i < n; i += 2)
			{

				//偶数
				cout << this_thread::get_id() << ":" << i << endl;

				cv2.notify_one(); //t1打印偶数以后，通知t2
				cv1.wait(unique_lock<mutex>(mtx1));

			}
		});

	thread t2([&]()
		{
			for (int i = 0; i < n; i += 2)
			{
				cv2.wait(unique_lock<mutex>(mtx2));//要传互斥锁来保护条件变量
				//奇数
				cout << this_thread::get_id() << ":" << i << endl;//利用this_thread可以不需要线程对象就获取到id
				cv1.notify_one(); //t2
			}
		});

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

	return 0;
}

---

应用场景4：

线程池

//扩展：线程池
struct tack
{
	template<class fn>
	tack(fn)
	{}
};

class thread_poo1
{
public:
	thread_poo1(int n = 8)
		:vthreads(n)
	{}

private:
	vector<thread> vthreads;
	//queue<task> _q;
};

---