C++11知识点汇总

一. 常用知识点总结

1. 关键字和语法

• auto：可以根据右值，推导右值的类型，然后左边变量的类型也就知道了
• nullptr：给指针专用（能够和整数进行区别）
• foreach：可以遍历数组，容器等

//底层就是通过指针或者迭代器来实现的
for(Type val:container)
{
	cout<<val<<" ";
}

• 右值引用：move移动语义函数和forward类型完美转发
• 模板的一个新特性：typename… A 表示可变参（类型参数）

3. 绑定器和函数对象

• function：函数对象
• bind：绑定器
• lambda表达式

function,bind和lambda详细讲解

3. 智能指针

智能指针可以自动管理资源，以防止代码不可预期的执行导致资源泄露、资源未释放。

shared_ptr和weak_ptr

4. 容器

unordered_set和unordered_map：哈希表

array：数组，无法进行扩容

forward_list：前向链表

5. C++语言级别支持多线程编程，代码可以跨平台
   增强了可移植性

二. 多线程类thread

C++语言层面的thread，其底层还是调用操作系统对象的多线程函数，例如windows下调用createThread，linux下调用的是pthread_create。语言层面的支持就做到了跨平台运行。

1. 怎么创建启动一个新线程？

std::thread定义一个线程对象，传入线程所需要的线程函数和参数，线程自动开启

2. 子线程如何结束？

子线程函数运行完成，线程就结束了

3. 主线程如何处理子线程

t.join()：等待 t 线程结束，当前线程继续往下运行
t.detach()：把 t 线程设置为分离线程，主线程结束，整个进程结束，所有子线程就自动结束。

示例代码：

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

void threadHandle(int time)
{
	//让子线程睡眠2秒
	//chrono:名词空间，定义了一些和时间有关的常量
	std::this_thread::sleep_for(std::chrono::seconds(time));
	cout << "hello thread!" << endl;
}
int main()
{
	//创建了一个线程对象，传入一个线程函数，新线程就开始运行了
	std::thread t1(threadHandle, 2);
	//主线程等待子线程结束，主线程继续往下运行
	//t1.join();
	//把子线程设置为分离线程，此时它跟主线程没有关系了
	t1.detach();
	cout << "main thread done" << endl;

	//主线程运行完成，查看如果当前进程还有未运行完成的子进程，进程就会异常终止
	return 0;
}

三. 线程互斥锁mutex

多线程互斥

竞态条件：多线程程序执行的结果是一致的，不会随着CPU对线程不同的调用顺序，而产生不同运行结果

C++ thread模拟车站三个窗口卖票程序，车站有100张票由三个窗口一起卖，代码实现：

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

//C++ thread模拟车站三个窗口卖票的程序
int ticketCount = 100;//车站有100张车票，由三个窗口一起卖票

//模拟卖票的线程函数
void sellTicket(int index)
{
	while (ticketCount > 0)
	{
		cout << ticketCount << endl;
		ticketCount--;
		std::this_thread::sleep_for(std::chrono::milliseconds(100));
	}
}
int main()
{
	list<std::thread> tlist;
	for (int i = 1; i <= 3; ++i)
	{
		tlist.push_back(std::thread(sellTicket, i));
	}
	for (std::thread& t : tlist)
	{
		t.join();
	}
	cout << "所有窗口卖票结束" << endl;
	return 0;
}

上面这段代码，启动三个线程模拟三个窗口同时卖票，总票数是100张，由于整数的--操作不是线程安全的操作

所以多线程环境中，需要通过加互斥锁做到线程安全。
代码如下：

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

//C++ thread模拟车站三个窗口卖票的程序
int ticketCount = 100;//车站有100张车票，由三个窗口一起卖票
std::mutex mtx;//全局的一把互斥锁
//模拟卖票的线程函数
void sellTicket(int index)
{
	while (ticketCount > 0)
	{
		mtx.lock();
		//不加if可能导致ticketCount=1时，两个线程同时进入while循环，导致ticketCount成为负数
		if(ticketCount>0)
		{
			//临界区代码段,需要保证原子操作，所以进行线程间互斥操作->mutex
			cout << "窗口"<<index<<"卖出第"<<ticketCount <<"张票" << endl;
			ticketCount--;
		}
		mtx.unlock();
		//每卖出一张票，睡眠100ms，让每个窗口都有机会卖票
		std::this_thread::sleep_for(std::chrono::milliseconds(100));
	}
}
int main()
{
	list<std::thread> tlist;
	for (int i = 1; i <= 3; ++i)
	{
		tlist.push_back(std::thread(sellTicket, i));
	}
	for (std::thread& t : tlist)
	{
		t.join();
	}
	cout << "所有窗口卖票结束" << endl;
	return 0;
}

lock_guard自动释放锁

由于互斥锁需要手动lock()，unlock()，可能导致unlock()调用不到。所以采用lock_guard()封装mutex，保证所以线程都能释放锁，防止死锁的发生。（就像智能指针一样，利用栈上的对象出作用域必须析构对象来释放空间）

void sellTicket(int index)
{
	while (ticketCount > 0)
	{
		lock_guard<std::mutex> lock(mtx);//相当于scope_ptr
		if (ticketCount > 0)
		{
			//临界区代码段,需要保证原子操作，所以进行线程间互斥操作->mutex
			cout << "窗口" << index << "卖出第" << ticketCount << "张票" << endl;
			ticketCount--;
		}
		std::this_thread::sleep_for(std::chrono::milliseconds(100));
	}
}

四. 线程间同步通信—生产者消费者模型

生产者-消费者模型：生产者线程生产出产品以后，会通知消费者线程去消费产品；如果消费者线程去消费产品，发现还没有产品生产出来，它需要通过线程生产出产品以后，消费者线程才能继续往下执行。使用条件变量和互斥锁实现的。

C++ STL所有容器都不是线程安全的，自己可以封装一个线程安全的。

#include<iostream>
#include<thread>
#include<mutex>
#include<condition_variable>//Linux平台下的condition_variable机制，用于解决线程间的同步通信问题
#include<queue>//C++ STL所有的容器都不是线程安全的
using namespace std;

/*
notify_one:通知另外的一个线程的
notify_all:通知其他所有线程的
通知其他所有线程，我生产了一个物品，赶紧消费吧
其他线程得知，就会从等待=>阻塞=>获取互斥锁才能继续执行
*/
std::mutex mtx;//定义互斥锁，做线程间的互斥操作
std::condition_variable cv;//定义条件变量，做线程间的同步通信操作

//生产者生产一个物品，通知消费者消费一个；消费完了，消费者再通知生产者继续生产物品
class Queue
{
public:
	void put(int val)//生产物品
	{
		unique_lock<std::mutex> lck(mtx);
		while (!que.empty())
		{
			//que不为空，生产者应该通知消费者去消费，消费完了，再继续生产
			//生产者线程进入等待状态，并且把mtx互斥锁释放掉
			cv.wait(lck);
		}
		que.push(val);
		cv.notify_all();
		cout << "生产者 生产" << val << "号物品" << endl;
	}
	int get()//消费物品
	{
		unique_lock<std::mutex> lck(mtx);
		while (que.empty())
		{
			cv.wait(lck);
		}
		int val = que.front();
		que.pop();
		cv.notify_all();//通知其他线程我消费完了，赶紧生产吧
		cout << "消费者 消费" << val << "号物品" << endl;
		return val;
	}
private:
	queue<int> que;
};

void producer(Queue *que)//生产线程
{
	for (int i = 0; i <= 10; i++)
	{
		que->put(i);
		std::this_thread::sleep_for(std::chrono::milliseconds(100));
	}
}
void consumer(Queue* que)//消费者线程
{
	for (int i = 0; i <= 10; i++)
	{
		que->get();
		std::this_thread::sleep_for(std::chrono::milliseconds(100));
	}
}

int main()
{
	Queue que;
	std::thread t1(producer,&que);
	std::thread t2(consumer,&que);

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

五. lock_guard和unique_lock

• mutex

mutex mtx;
	
int main(){
	mtx.lock();   // 获取
	mtx.unlock(); // 释放
}

写法类似于裸指针，可能出现获取但没释放的情况。

• lock_guard

lock_guard类似于智能指针，构造函数获取锁，析构函数释放锁。

部分源码如下，禁止拷贝构造和赋值

	lock_guard(const lock_guard&) = delete;
    lock_guard& operator=(const lock_guard&) = delete;

用法：

lock_guard<std::thread> guard(mtx);

lock_guard不可能用在函数参数传递或者返回过程中，因为这些会用到拷贝构造或赋值函数，但lock_guard不能进行拷贝构造和赋值，只能用在简单的加锁和解锁临界区代码段中。

• unique_lock

同样是构造函数获取锁，析构函数释放锁。

删除了左值的拷贝构造和等号运算符重载，提供了右值的拷贝构造和等号运算符重载，unique_lock不仅可用于函数的参数传递以及返回过程中，还可用在简单的临界区代码段的互斥操作中。

底层也提供了互斥锁的lock()和unlock()方法

用法如下:

unique_lock<std::thread> lck(mtx);

unique_lock完全可以替代lock_guard，就像unique_ptr完全可以替代scoped_ptr一样。只是多了个条件变量的功能（线程同步通信）

• condition_variable

通常和unique_lock搭配使用

	unique_lock<mutex> lck(mtx);
	// 1. 使线程进入等待状态
	// 2. lck.unlock()释放互斥锁mtx
	cv.wait(lck);

	// 通知cv上等待的线程从等待状态进入阻塞状态，开始抢互斥锁
	// 抢到互斥锁的线程从阻塞->运行
	cv.notify_all();

六. 基于CAS操作的atomic原子类型

互斥锁是比较重的，适合于临界区代码做的事情稍稍复杂的情形。而++,--操作使用CAS原子特性就足够了，是无锁操作。

CAS并不是不加锁，只不过加锁解锁不在软件层面。cpu和内存之间通信通过系统总线进行。CAS通过exchange/swap指令，相当于给总线加锁，当一个线程在做cpu和内存交换，不允许其他线程再使用总线，有助于提高多线程效率。

volatile：防止多线程对共享变量进行缓存，访问的都是原始内存变量值。

不加volatile的话，每个线程都会拷贝一份自己的线程栈上的变量，带到CPU的缓存，这样效率较高，但也可能出错。

#include <iostream>
#include <thread>
#include <list>
#include <atomic>

using namespace std;

volatile atomic_bool is_ready = false;
volatile atomic_int cnt = 0;

void task() {
	if (!is_ready) {
		// 当前线程让出时间片
		this_thread::yield();
	}
	// 每个线程都加100次
	for (int i = 0; i < 100; i++) {
		cnt++;
	}
}

int main(){
	list<thread> tlist;
	for (int i = 0; i < 10; i++) {
		tlist.push_back(thread(task));
	}
	this_thread::sleep_for(chrono::seconds(2));
	is_ready = true;
	for (thread& t : tlist) {
		t.join();
	}
	cout << cnt << endl; // 1000
	return 0;
}