目录

前言

一、统一的列表初始化

1、｛｝初始化

2、std::itializer_list 

二、 右值引用和移动语义 

1、概念

2、左值引用和右值引用比较

3、右值引用使用场景和意义

3.1 移动构造和移动赋值

3.2 move函数

 3.3 右值引用传参

4、完美转发 

三、新的类功能

1、新增默认成员函数

 2、default和delete

四、可变模板参数

五、lambda表达式 

1、概念

2、函数对象与lambda表达式

六、包装器

七、线程库

1、简单介绍

2、原子性操作库

3、 lock_guard与unique_lock

3.1 mutex的种类

3.2 lock_guard

3.3 unique_lock 

八、举例：两个线程交替打印

总结

前言

C++11对比C++98带来了数量可观的变化，增加了很多新特性。相比较而言C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率，公司实际项目开发中也用得比较多。所以对C++11的学习是很重要的。

一、统一的列表初始化

1、｛｝初始化

在C++98中，标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定。C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。

int main()
{
	int x1 = 1;
    //我们知道有不加等号这种写法即可，自己写的时候最好还是要加上
	int x2{ 2 };
	int array1[]{ 1, 2, 3, 4, 5 };
	int array2[5]{ 0 };
	// C++11中列表初始化也可以适用于new表达式中
	int* pa = new int[4]{ 0 };
	return 0;
}

同时也可以用来初始化对象：

class Date
{
public:
	Date(int year, int month, int day)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		cout << "Date(int year, int month, int day)" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2022, 1, 1); // old style
	// C++11支持的列表初始化，这里会调用构造函数初始化
	Date d2{ 2022, 1, 2 };
	Date d3 = { 2022, 1, 3 };
	return 0;
}

2、std::itializer_list 

std::itializer_list是一种什么类型呢？

int main()
{
	// the type of il is an initializer_list
	auto il = { 10, 20, 30 };
	cout << typeid(il).name() << endl;
	return 0;
}

可以看出编译器会将大括号转化为std::itializer_list类型。

 Initializer_list是c++11新增加的一个类型，和数组类似，它主要用来初始化。std::initializer_list一般是作为构造函数的参数，C++11对STL中的不少容器就增加std::initializer_list作为参数的构造函数。

 这样初始化容器对象就更方便了。也可以作为operator=的参数，这样就可以用大括号赋值。

int main()
{
vector<int> v = { 1,2,3,4 };
list<int> lt = { 1,2 };
// 这里{"sort", "排序"}会先初始化构造一个pair对象
map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
// 使用大括号对容器赋值
v = {10, 20, 30};
return 0;

二、 右值引用和移动语义 

1、概念

传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，所以从现在开始我们
之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。

什么是左值？什么是右值？

左值可以取地址，可以出现在等号左边，可以改变值的大小（const类型除外）。

右值不可以被取地址，不可以出现在等号左边，只能出现在等号右边，不可以改变值的大小。右值一般有两种，一种是纯右值，一种是将亡值（函数返回的临时变量）。

2、左值引用和右值引用比较

左值引用总结：

• 左值引用一般情况下只能引用左值，不能引用右值。
• 但是const左值引用既可以引用左值也可以引用右值。

int main()
{
  // 左值引用只能引用左值，不能引用右值。
  int a = 10;
  int& ra1 = a;  // ra1为a的别名
  //int& ra2 = 10;  // 编译失败，因为10是右值
  // const左值引用既可引用左值，也可引用右值。
  const int& ra3 = 10;
  const int& ra4 = a;
  return 0;
}

 右值引用总结：

• 右值引用只能右值，不能引用左值。
• 但是右值引用可以move以后的左值。move是一个函数，可以将左值转化为右值。

int main()
{
    // 右值引用只能右值，不能引用左值。
    int&& r1 = 10;
    // error C2440: “初始化”: 无法从“int”转换为“int &&”
    // message : 无法将左值绑定到右值引用
    int a = 10;
    int&& r2 = a;
    // 右值引用可以引用move以后的左值
    int&& r3 = std::move(a);
    return 0;
}

需要注意的是，右值虽然不能被取地址，但右值被取别名后会存储到特定的位置，这个特定位置的地址是可以被取地址的。也就是说字面量10为右值不能被取地址，但是右值引用取别名为r1后，r1的地址是可以取到的，并且r1的值是可以被修改的，如果不想rr1被修改，可以用const int&& r1 去引用。当然右值引用的实际用处并不在此，只需要了解即可。

3、右值引用使用场景和意义

3.1 移动构造和移动赋值

前面我们可以看到左值引用加const后既可以引用左值和又可以引用右值，那为什么C++11还要提出右值引用呢？原因是右值引用可以补足左值引用的短板。

我们先来看一下左值引用的优势：在左值引用做参数或者做返回值时能够很好的减少拷贝次数，从而提高效率。

void func1(bit::string s)
{}
void func2(const bit::string& s)
{}
int main()
{
	bit::string s1("hello world");
	// func1和func2的调用我们可以看到左值引用做参数减少了拷贝，提高效率的使用场景和价值
	func1(s1);
	func2(s1);
	// string& operator+=(char ch) 传左值引用没有拷贝提高了效率
	s1 += '!';
	return 0;
}

但是当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。例如：bit::string to_string(int value)函数中可以看到，这里只能使用传值返回，传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造，先把这个值拷贝给一个临时变量，然后临时变量在拷贝给接收值)。

在值拷贝过程中发生了深拷贝，效率是很低的，为了解决这一问题，c++增加了移动构造和移动赋值。

移动构造：

	// 移动构造
    //初始化一下数据，和s交换
		string(string&& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			cout << "string(string&& s) -- 移动构造" << endl;
			this->swap(s);
		}

        int main()
        {
            bit::string ret2 = bit::to_string(-1234);
            return 0;
        }

 在发生拷贝时，编译器会优先把bit::string to_string(int value)函数的返回值当成右值处理，如果类中有移动构造则调用移动构造，没有移动构造再调用拷贝构造。

移动赋值:

只有在定义ret1时接收返回值编译器才能进行优化成一次构造，像下面这样写编译器需要将bit::string to_string(1234)的值构造形成临时变量，再将临时变量赋值给ret1。上面提到过，编译器会优先返回值当成右值去处理，故移动构造出临时变量，再移动赋值给ret1。

// 移动赋值
string& operator=(string&& s)
{
	cout << "string& operator=(string&& s) -- 移动语义" << endl;
	this->swap(s);
	return *this;
}
int main()
{
	bit::string ret1;
	ret1 = bit::to_string(1234);
	return 0;
}

// 运行结果：
// string(string&& s) -- 移动构造
// string& operator=(string&& s) -- 移动赋值

移动构造和移动赋值的效率是很高的，它的本质是把右值的资源窃取过来占为己有，就不用再花力气拷贝了。反正右值一般是会快速消失的，即便资源被窃取了也不会有影响。

3.2 move函数

按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？因为：有些场景下，可能真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。C++11中，std::move()函数位于 头文件中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。 

但要注意，被强制转化为右值的左值资源可能会被掠夺，掠夺之后不能在使用这些资源，否则会出错。 

int main()
{
	bit::string s1("hello world");
	// 这里s1是左值，调用的是拷贝构造
	bit::string s2(s1);
	// 这里我们把s1 move处理以后, 会被当成右值，调用移动构造
	// 但是这里要注意，一般是不要这样用的，因为我们会发现s1的
	// 资源被转移给了s3，s1被置空了。
	bit::string s3(std::move(s1));
	return 0;
}

 3.3 右值引用传参

C++11后，STL容器插入接口函数也增加了右值引用做参数的版本。

int main()
{
	list<bit::string> lt;
	bit::string s1("1111");
	// 这里调用的是拷贝构造
	lt.push_back(s1);
	// 下面调用都是移动构造
	lt.push_back("2222");
	lt.push_back(std::move(s1));
	return 0;
} 

 如果是左值引用插入在申请节点空间的时候会采用拷贝构造，如果是右值引用插入则会使用移动构造。

4、完美转发 

模板中的&& 万能引用： 

• 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
• 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力 。

我们通过代码测试一下，看看万能模板是不是如我们想象的那样，注释的内容是理想的打印内容：

void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }

template<typename T>
void PerfectForward(T&& t)
{
	Fun(t);
}
int main()
{
	PerfectForward(10);      // 右值
	int a;
	PerfectForward(a);       // 左值
	PerfectForward(std::move(a)); // 右值
	const int b = 8;
	PerfectForward(b);    // const 左值
	PerfectForward(std::move(b)); // const 右值
	return 0;
}

实际情况并不像我们想象的那样，打印出来的全部都是左值引用。

 这是因为右值引用的对象，再次传递时会退化成左值引用，其实这很好理解，上文我们提到过，右值一旦被引用就会被存在一个特定的地方并且可以取到地址，所以再次使用时编译器就会把它当成左值了。想要保持它的右值属性，就要使用完美转发。

 std::forward 完美转发在传参的过程中保留对象原生类型属性：

只要在传参是时候加上完美转发，就可以保留右值属性。

template<typename T>
void PerfectForward(T&& t)
{
    Fun(std::forward<T>(t));
}

在实际中的应用：

void Insert(Node* pos, T&& x)
{
	Node* prev = pos->_prev;
	Node* newnode = new Node;
	newnode->_data = std::forward<T>(x); // 关键位置
	// prev newnode pos
	prev->_next = newnode;
	newnode->_prev = prev;
	newnode->_next = pos;
	pos->_prev = newnode;
}

三、新的类功能

1、新增默认成员函数

原来C++类中，有6个默认成员函数：

• 构造函数
• 析构函数
• 拷贝构造函数
• 拷贝赋值重载
• 取地址重载
• const 取地址重载

当然，我们平常很少用到后两个。在C++11中，又新增了两个默认构造函数，分别是移动构造和移动赋值。

• 如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。
• 如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。。(默认移动赋值跟上面移动构造完全类似)

 2、default和delete

强制生成默认函数的关键字default:

C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用default关键字显示指定移动构造生成。

Person(Person&& p) = default;

禁止生成默认函数的关键字delete: 

如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明补丁
已，这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明加上=delete即
可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。

Person(const Person& p) = delete;

四、可变模板参数

C++11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板，相比C++98，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。

// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}

上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包args中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。由于语法不支持使用args[i]这样方式获取可变参数，所以我们的用一些特殊的方法来获取参数包的值。 

// 递归终止函数
template <class T>
void ShowList(const T& t)
{
	cout << t << endl;
}
// 展开函数
template <class T, class ...Args>
void ShowList(T value, Args... args)
{
	cout << value << " ";
	ShowList(args...);
}
int main()
{
	ShowList(1);
	ShowList(1, 'A');
	ShowList(1, 'A', std::string("sort"));
	return 0;
}

在上面的展开函数中，每次 都会取参数包中第一个值出来，剩下的作为一个新的参数包递归下去。要注意的是想终止递归必须要单独写一个递归终止函数，不能在展开函数中终止。因为模板推演是一个编译是逻辑，而在展开函数中终止是运行时逻辑，不能达到目的。

STL容器中的empalce相关接口函数：

在C++11中很多容器添加了emplace系列的接口，支持模板的可变参数，并且万能引用。

emplace和insert都是用来插入的函数，那么相对insert和emplace系列接口的优势到底在哪里呢？

其实一般来说，emplace和insert并没有太大区别，对于某些情况下来说来说，效率会得到一定的提升。emplace_back支持可变参数，拿到构建pair对象的参数后自己去创建对象。

int main()
{
	// 我们会发现其实差别也不到，emplace_back是直接构造了
	// ，push_back是先构造，再移动构造，其实也还好。
	std::list< std::pair<int, bit::string> > mylist;
	mylist.emplace_back(10, "sort");//会直接去调构造函数
	mylist.push_back(make_pair(30, "sort"));
	mylist.push_back({ 40, "sort" });
	return 0;
}

五、lambda表达式 

1、概念

在C++98中，如果想要对一个数据集合中的元素进行排序，可以使用sort函数。如果待排序元素为自定义类型，需要用户使用仿函数定义排序时的比较规则。随着C++语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个algorithm算法，都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，这些都给编程者带来了极大的不便。因此，在C++11语法中出现了Lambda表达式。

lambda表达式语法：

lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement}

• [capture-list]：捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[ ]判断接下来的函数是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
•  (parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以
  连同()一起省略。
• mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
• ->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
• {statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获
  到的变量。

注意：
在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。

捕获列表说明：

• 捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。
• [var]：表示值传递方式捕捉变量var。
• [=]：表示值传递方式捕获所有父作用域中的变量(包括成员函数中的this)。
• [&var]：表示引用传递捕捉变量var。
• [&]：表示引用传递捕捉所有父作用域中的变量(包括成员函数中的this)。
• [this]：表示值传递方式捕捉当前的this指针。

int main()
{
	//实现add的lambda
	auto add = [](int a, int b)->int {return a + b; };
	cout << add(1, 2)<<endl;

	//实现swap的lamba
	//标准写法
	auto swap1 = [](int& a, int& b)
	{
		int temp = a;
		a = b;
		b = temp;
	};
	
	int a = 10, b = 20;
	//使用捕捉列表
	auto swap2 = [&a, &b]
	{
		int temp = a;
		a = b;
		b = temp; 
	};
}

2、函数对象与lambda表达式

函数对象，又称为仿函数，即可以想函数一样使用的对象，就是在类中重载了operator()运算符的
类对象。

lambda表达式可以很好的代替仿函数使用，如果使用仿函数，阅读代码的人想要知道其中的逻辑还需要去对应的地方去找，而lambda表达式可以很好的避免这个问题，增强了代码的可读性：

int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
3 }, { "菠萝", 1.5, 4 } };
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
return g1._price < g2._price; });
}

从使用方式上来看，函数对象与lambda表达式完全一样。实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。 

六、包装器

function包装器 也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。那么我们来看看，我们为什么需要function呢？

ret = func(x);

上面的func可能是什么呢？可能是函数名，可能是函数指针，可能是仿函数，也可能是lambda表达式。这些都是可调用对象，可以做函数参数。

template<class F, class T>
T useF(F f, T x)
{
    return f(x);
}
int main()
{
    // 函数名
    cout << useF(f, 11.11) << endl;
    // 函数对象
    cout << useF(Functor(), 11.11) << endl;
    // lamber表达式
    cout << useF([](double d)->double{ return d/4; }, 11.11) << endl;
    return 0;
}

通过上面的程序验证，我们会发现useF函数模板实例化了三份,很浪费资源，包装器可以很好的解决这个问题。

//std::function在头文件<functional>
template <class Ret, class... Args>
class function<Ret(Args...)>;

模板参数说明：

• Ret: 被调用函数的返回类型
• Args…：被调用函数的形参

int main()
{
    // 函数名(函数指针)
    std::function<int(int, int)> func1 = f;
    cout << func1(1, 2) << endl;
    // 函数对象
    std::function<int(int, int)> func2 = Functor();
    cout << func2(1, 2) << endl;
    // lamber表达式
    std::function<int(int, int)> func3 = [](const int a, const int b)
    {return a + b; };
}

包装器的作用：统一可调用对象的类型，指明了参数和返回值类型

不包装前可能存在很多问题：

• 函数指针太复杂，不方便理解。
• 仿函数类型是一个类名，没有指明参数和返回值，需要去operator()才能看出来。
• lambda表达式在语法层看不到类型。

七、线程库

1、简单介绍

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

注意：

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

线程对象构造函数：

•  第一个构造函数创建了空线程对象，没有关联任何线程函数。
• 第二个构造函数：第一个参数为线程函数，之后传的是线程函数的参数。
• 线程对象不能拷贝，但可以转移（常常配合空线程对象使用）。

创建一个线程：

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

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

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

jionable() 函数：

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

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

其它接口和Linux下类似，查阅相关文档学习即可。

2、原子性操作库

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

传统的解决办法是加锁保护，虽然加锁可以解决，但是加锁有一个缺陷，就是在加锁过程中其它线程会被阻塞，影响效率。如果加锁仅仅是为了完成一些简单操作，就会显得非常不划算。而且锁如果控制不好，还容易造成死锁。所以在c++11中引入了原子操作。

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

需要使用以上原子操作变量时，必须添加头文件。在C++11中，程序员不需要对原子类型变量进行加锁解锁操作，线程能够对原子类型变量互斥的访问。 

更为普遍的，程序员可以使用atomic类模板，定义出需要的任意原子类型。

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

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

3、 lock_guard与unique_lock

在多线程环境下，如果想要保证某个变量的安全性，只要将其设置成对应的原子类型即可，即高
效又不容易出现死锁问题。但是有些情况下，我们可能需要保证一段代码的安全性，那么就只能
通过锁的方式来进行控制。

3.1 mutex的种类

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

（1）mutex

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

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

（2）recursive_mutex

如果在递归函数中使用普通锁，会发生重复加锁导致死锁。这时候就要用到recursive_mutex，其允许同一个线程对互斥量多次上锁（即递归上锁），来获得对互斥量对象的多层所有权，释放互斥量时需要调用与该锁层次深度相同次数的 unlock()，除此之外，std::recursive_mutex 的特性和 std::mutex 大致相同。

（3）timed_mutex

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

• try_lock_for()

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

• try_lock_until()

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

（4）recursive_timed_mutex

3.2 lock_guard

在使用锁时很容易发生死锁问题，比如在解锁之前函数进行了return或报异常。因此：C++11采用RAII的方式对锁进行了封装，即lock_guard和unique_lock。

lock_gurad 是 C++11 中定义的模板类。定义如下：

template<class Lock>
	class lock_guard
	{
	public:
		lock_guard(Lock& lock)
			:_lock(lock)
		{
			_lock.lock();
			cout << "加锁" << endl;
		}
  
        ~lock_guard()
		{
			_lock.unlock();
			cout << "解锁" << endl;
		}

		lock_guard(const lock_guard<Lock>& lock) = delete;
        lock_guard& operator=(const lock_guard& lock) = delete;
      private:
		Lock& _lock;
	};

在构造lock_guard对象的时候会自动上锁，当出作用域lock_guard对象析构的时候又会自动解锁，可以有效避免死锁问题。

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

3.3 unique_lock 

与lock_gard类似，unique_lock类模板也是采用RAII的方式对锁进行了封装，并且也是以独占所
有权的方式管理mutex对象的上锁和解锁操作，即其对象之间不能发生拷贝。与lock_guard不同的是，unique_lock更加的灵活，提供了更多的成员函数：

上锁/解锁操作：lock、try_lock、try_lock_for、try_lock_until和unlock

八、举例：两个线程交替打印

我们最先想到的是下面这种方法：

int main()
{
	int n = 100;
	mutex mtx;
	// 奇数 假设 thread2迟迟没创建好或者没有排到cpu时间片，就会导致t1连续打印奇数，不符合题意要求
	thread t1([&](){
		int i = 1;
		for (; i < n; i += 2)
		{
			unique_lock<mutex> lock(mtx);
			cout << i << endl;
		}
	});
	// 偶数
	thread t2([&](){
		int j = 2;
		for (; j < n; j += 2)
		{
			unique_lock<mutex> lock(mtx);
			cout << j << endl;
		}
	});
	t1.join();
	t2.join();
	return 0;
}

这种方法在大部分情况下确实可以满足要求，但在某些情况下会出现问题：

• 我们无法保证thread t1和 thread t2哪个线程先创建，即便我们在代码中先创建thread t1，但在极少数情况下依旧会出现thread t2先创建的情况。
• 如果thread t2因为某些原因迟迟没有创建好，或者没有排到cpu的时间片，会出现thread t1连续打印的情况。

为了解决上面的问题，要使用到条件变量。在c++中，条件变量的wait接口比较特殊：

可以看到第二个接口中增加了pred参数，predicate这个单词的意思是以什么为根据， pred需要传一个可调用对象，以这个可调用对象的返回值为根据做出判断。

 如果pred的返回值是false，则线程会一直阻塞，即便被唤醒了也会再次陷入等待。如果是true则会继续往下运行。

代码如下：

int main()
{
	int n = 100;
	mutex mtx;
	condition_variable cv;
	bool flag = true;
	//打印奇数
	thread t1([&]()
		{
			for (int i = 1; i <=n; )
			{
				//这里要用unique_lock，因为在线程等待的时候需要对锁进行释放，需要有释放锁的接
				unique_lock<mutex> lock(mtx);
				cv.wait(lock, [&flag] {return flag; });
				cout << i << endl;
				i += 2;
				flag = false;
				cv.notify_one();
			}
		});
	//打印偶数
	thread t2([&]()
		{
			for (int j = 2; j <= n; )
			{
				//这里要用unique_lock，因为在线程等待的时候需要对锁进行释放，需要有释放锁的接
				unique_lock<mutex> lock(mtx);
				cv.wait(lock, [&flag] {return !flag; });
				cout << j << endl;
				j += 2;
				flag = true;
				cv.notify_one();
			}
		});
	t1.join();
	t2.join();
}

这样可以很少的解决特殊情况下可能出现的问题。比如线程1启动后线程2迟迟没有启动起来，这时候线程1是无法做到多次打印的，因为打印一次后flag就会变为true，线程1wait的时候就会被阻塞住，必须等线程2启动后调整flag的值。再或者线程2刚刚释放锁还没来得及进入等待队列就被切走了，同理线程1在线程2被切走后的这段时间内打印一次就会被阻塞，必须等线程2切回来后改变falg的值才能被唤醒。

总结

本文主要简单介绍了C++11新增的语法特性，希望可以给大家带来帮助。江湖路远，来日方长，我们下次见。