C++11 -------- 线程库

在C++11之前，涉及到多线程问题，都是和平台相关的，比如Windows和Linux下各有自己的接口，这使得代码的可移植性比较差。
C++11中最重要的特性就是对线程进行了支持，使得C++在并行编程时不需要依赖第三方库，而且在原子操作中还引入了原子类的概念。
C++11的thread库可以跨平台，通过条件编译写了一套跨平台的代码，Linux系统就调用Linux的线程库函数； Windows系统就调用Windows的线程库函数
C++11 是面向对象的

1.线程对象的构造方式

(1)调用无参的构造函数

thread提供了无参的构造函数，调用无参的构造函数创建出来的线程对象没有关联任何线程函数，即没有启动任何线程
由于thread提供了移动赋值函数，因此当后续需要让该线程对象与线程函数关联时，可以以带参的方式创建一个匿名对象，然后调用移动赋值将该匿名对象关联线程的状态转移给该线程对象
实现线程池的时候就是需要先创建一批线程，但一开始这些线程什么也不做，当有任务到来时再让这些线程来处理这些任务

void func(int n)
{
	for (int i = 0; i <= n; i++)
	{
		cout << i << endl;
	}
}

int main()
{
	thread t1;  //无参构造
	//...
	t1 = thread(func, 10);

	t1.join();
	return 0;
}

(2)调用带参的构造函数

①thread的带参的构造函数的定义

template <class Fn, class... Args>
explicit thread (Fn&& fn, Args&&... args);

②参数说明

fn : 可调用对象，比如函数指针、仿函数、lambda表达式、被包装器包装后的可调用对象等。
args... : 调用可调用对象fn时所需要的若干参数。

③使用

调用带参的构造函数创建线程对象，能够将线程对象与线程函数fn进行关联

void func(int n)
{
	for (int i = 0; i <= n; i++)
	{
		cout << i << endl;
	}
}

int main()
{
	thread t2(func, 10);

	t2.join();
	return 0;
}

(3)调用移动构造函数

thread提供了移动构造函数，能够用一个右值线程对象来构造一个线程对象

void func(int n)
{
	for (int i = 0; i <= n; i++)
	{
		cout << i << endl;
	}
}

int main()
{
	thread t3 = thread(func, 10);

	t3.join();
	return 0;
}

(4)补充

线程是操作系统中的一个概念，线程对象可以关联一个线程，用来控制线程以及获取线程的状态。
如果创建线程对象时没有提供线程函数，那么该线程对象实际没有对应任何线程。
如果创建线程对象时提供了线程函数，那么就会启动一个线程来执行这个线程函数，该线程与主线程一起运行。
thread类是防拷贝的，不允许拷贝构造和拷贝赋值，但是可以移动构造和移动赋值，可以将一个线程对象关联线程的状态转移给其他线程对象，并且转移期间不影响线程的执行。

2.thread提供的成员函数

成员函数	功能
join	对该线程进行等待，在等待的线程返回之前，调用join函数的线程将会被阻塞
joinable	判断该线程是否已经执行完毕，如果是则返回true，否则返回false
detach	将该线程与创建线程进行分离，被分离后的线程不再需要创建线程调用join函数对其进行等待
get_id	获取该线程的id
swap	将两个线程对象关联线程的状态进行交换

补充: joinable函数还可以用于判定线程是否是有效的，如果是以下任意情况，则线程无效：

采用无参构造函数构造的线程对象。（该线程对象没有关联任何线程）
线程对象的状态已经转移给其他线程对象。（已经将线程交给其他线程对象管理）
线程已经调用join或detach结束。（线程已经结束）

3.获取线程id方式

(1)通过thread成员函数获取get_id

①调用thread的成员函数get_id可以获取线程的id，但该方法必须通过线程对象来调用get_id函数，如果要在线程对象关联的线程函数中获取线程id，可以调用this_thread命名空间下的get_id函数

void func()
{
	cout << "线程id : " << this_thread::get_id() << endl;//获取线程id
}

int main()
{
	thread t1(func);
	thread t2(func);

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

注意 : 两个线程是两个执行流，而显示器只有一个，因此t1 , t2线程对于显示器资源竞争导致显示问题

②解决：先让t1线程执行，t2线程后执行

void func()
{
	cout << "线程id : " << this_thread::get_id() << endl;//获取线程id
}

int main()
{
	thread t1(func);

	Sleep(1000); //主线程休眠1s windows.h
	thread t2(func);

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

(2)this_thread命名空间中还提供了以下三个函数

函数名	功能
yield	当前线程“放弃”执行，让操作系统调度另一线程继续执行
sleep_until	让当前线程休眠到一个具体时间点
sleep_for	让当前线程休眠一个时间段

4.线程函数的参数问题

(1)问题引出

线程函数的参数是以值拷贝的方式拷贝到线程栈空间中的，就算线程函数的参数为引用类型，在线程函数中修改后也不会影响到外部实参，因为其实际引用的是线程栈中的拷贝，而不是外部实参

这段程序在vs2019上面直接报错，不能执行
这段程序在vs2013上面可以执行，两个num的地址不同，值不同；可以认为是vs2013支持C++11的bug
严格来说thread可执行函数参数不能是左值引用，这时底层原因导致的

void add(int& num)
{
    num++;
    cout << &num << endl;
}

int main()
{
	int num = 0;
	thread t(add, num);
	t.join();

    cout << &num << endl;
	cout << num << endl; 
	return 0;
}

(2)借助std::ref函数改变外部的实参

当线程函数的参数类型为引用类型时，如果要想线程函数形参引用的是外部传入的实参，而不是线程栈空间中的拷贝，那么在传入实参时需要借助ref函数保持对实参的引用

void add(int& num)
{
	num++;
}

int main()
{
	int num = 0;
	thread t(add, ref(num));
	t.join();

	cout << num << endl; //1
	return 0;
}

(3)使用指针改变外部的实参

将线程函数的参数类型改为指针类型，将实参的地址传入线程函数，此时在线程函数中可以通过修改该地址处的变量，进而影响到外部实参

void add(int* num)
{
	(*num)++;
}

int main()
{
	int num = 0;
	thread t(add, &num);
	t.join();

	cout << num << endl; //1
	return 0;
}

(4)借助lambda表达式

将lambda表达式作为线程函数，利用lambda函数的捕捉列表，以引用的方式对外部实参进行捕捉，此时在lambda表达式中对形参的修改也能影响到外部实参

int main()
{
	int num = 0;
	thread t([&num]{num++; });
	t.join();

	cout << num << endl; //1
	return 0;
}

5.join与detach

启动一个线程后，当这个线程退出时，需要对该线程所使用的资源进行回收，否则可能会导致内存泄露等问题

(1)join方式

主线程创建新线程后，可以调用join函数等待新线程终止，当新线程终止时join函数就会自动清理线程相关的资源。

①join函数清理线程的相关资源后，thread对象与已销毁的线程就没有关系了，因此一个线程对象一般只会使用一次join，否则程序会崩溃

void func(int n)
{
	for (int i = 0; i <= n; i++)
	{
		cout << i << endl;
	}
}

int main()
{
	thread t(func, 20);
	t.join();
	t.join(); //程序崩溃
	return 0;
}

②但如果一个线程对象join后，又调用移动赋值函数，将一个右值线程对象的关联线程的状态转移过来了，那么这个线程对象又可以调用一次join

void func(int n)
{
	for (int i = 0; i <= n; i++)
	{
		cout << i << endl;
	}
}

int main()
{
	thread t(func, 20);
	t.join();

	t = thread(func, 30);
	t.join();
	return 0;
}

③采用join的方式结束线程，在某些场景下也可能会出现问题。比如在该线程被join之前，如果中途因为某些原因导致程序不再执行后续代码，这时这个线程将不会被join。

void func(int n)
{
	for (int i = 0; i <= n; i++)
	{
		cout << i << endl;
	}
}

bool DoSomething()
{
	return false;
}

int main()
{
	thread t(func, 20);

	//...
	if (!DoSomething())
		return -1;
	//...

	t.join(); //不会被执行
	return 0;
}

④采用join方式结束线程时，join的调用位置非常关键，为了避免上述问题，可以采用RAII的方式对线程对象进行封装，也就是利用对象的生命周期来控制线程资源的释放

class myThread
{
public:
	myThread(thread& t)
		:_t(t)
	{}
	~myThread()
	{
		if (_t.joinable())
			_t.join();
	}

	//防拷贝
	myThread(myThread const&) = delete;
	myThread& operator=(const myThread&) = delete;
private:
	thread& _t;
};


int main()
{
	thread t(func, 20);
	myThread mt(t); //使用myThread对线程对象进行封装

	//...
	if (!DoSomething())
		return -1;
	//...

	t.join();
	return 0;
}

每当创建一个线程对象后，就用myThread类对其进行封装产生一个myThread对象。
当myThread对象生命周期结束时就会调用析构函数，在析构中会通过joinable判断这个线程是否需要被join，如果需要那么就会调用join对其该线程进行等待。

(2)detach

主线程创建新线程后，也可以调用detach函数将新线程与主线程进行分离，分离后新线程会在后台运行，其所有权和控制权将会交给C++运行库，此时C++运行库会保证当线程退出时，其相关资源能够被正确回收。

使用detach的方式回收线程的资源，一般在线程对象创建好之后就立即调用detach函数。
否则线程对象可能会因为某些原因，在后续调用detach函数分离线程之前被销毁掉，这时就会导致程序崩溃。
因为当线程对象被销毁时会调用thread的析构函数，而在thread的析构函数中会通过joinable判断这个线程是否需要被join，如果需要那么就会调用terminate终止当前程序（程序崩溃）。

6.线程安全问题

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

(1)两个线程对同一个变量相加

输出结果错误

void func(int& n, int times)
{
	for (int i = 0; i < times; i++)
	{
		n++;
	}
}

int main()
{
	int n = 0;
	int times = 100000; //每个线程对n++的次数
	thread t1(func, ref(n), times);
	thread t2(func, ref(n), times);

	t1.join();
	t2.join();
	cout << n << endl; //打印n的值
	return 0;
}

(2)线程安全加锁解决

在哪个地方加锁比较好？

void func(int& n, int times)
{   
	//1.for循环体外加锁
	for (int i = 0; i < times; i++)
	{   
		//2.for循环体内加锁
		n++;
	}
}

①对加锁位置的解读

此处在for循环体外加锁比在for循环体内加锁更高效，因为在for循环体内加锁会导致线程打印数字时频繁进行加锁解锁操作，而如果在for循环体外加锁，那么这两个线程只需要在开始n++之前进行一次加锁，在打印完100后进行一次解锁就行了。
在for循环体外加锁也就意味着两个线程的 n++ 过程变成了串行的，即一个线程++次数够了另一个线程再++ ，没有频繁的锁的申请和释放。(锁的申请和释放也是要消耗资源的)
因为n++进行了的太快了，如果使用for循环体内加锁，那么关于效率的主要矛盾就是线程的频繁切换，线程频繁的切换上下文导致效率降低
如果想要在for循环体内加锁，不要使用互斥锁，使用自旋锁
互斥锁加锁失败后，线程释放CPU，给其他线程 ; 自旋锁加锁失败后，线程会忙等待，直到它拿到锁；持有互斥锁的线程在看到锁已经有主了之后，就会礼貌的退出，等待之后锁释放时自己被系统唤醒；而自旋锁呢，它在反复的询问锁使用完了没有

②for循环体外加锁

为了保证两个线程使用的是同一个互斥锁，线程函数必须以引用的方式接收传入的互斥锁，并且在传参时需要使用 ref 函数保持对互斥锁的引用。
此外，也可以将互斥锁定义为全局变量，或是用lambda表达式定义线程函数，然后以引用的方式将局部的互斥锁进行捕捉，这两种方法也能保证两个线程使用的是同一个互斥锁。

void func(int& n, int times , mutex& mtx)
{
	mtx.lock(); //for循环体外加锁
	for (int i = 0; i < times; i++)
	{
		n++;
	}
	mtx.unlock();
}

int main()
{
    int n = 0;
	mutex mtx;
	thread t1(func, ref(n) , 100000, ref(mtx));
	thread t2(func, ref(n) , 100000, ref(mtx));

    cout << n << endl; //200000
	t1.join();
	t2.join();
	return 0;
}

补充 :

在项目中实际不太建议定义全局变量(互斥锁)，因为全局变量如果定义在头文件中，当这个头文件被多个源文件包含时，在这多个源文件中都会对这个全局变量进行定义，这时就会导致变量重定义，但如果将全局变量定义为静态，那这个全局变量就只在当前文件可见。
如果确实有一些变量需要在多个文件中使用，那么一般建议将这些变量封装到一个类当中，然后将这个类设计成单例模式，当需要使用这些变量时就通过这个单例对象去访问即可。

③for循环体内，体外效率对比

int main()
{
	int n = 0;
	int times = 1000000;
	int coastTime = 0;
	mutex mtx;

	thread t1([&]() {
		int begin1 = clock();
        //mtx.lock();  --锁外
		for (int i = 0; i < times; ++i)
		{
			mtx.lock();  //--锁内
			++n;
			mtx.unlock();
		}
        //mtx.unlock();
		int end1 = clock();

		coastTime += (end1 - begin1);
	});

	thread t2([&]() {
		int begin2 = clock();
		//mtx.lock();
		for (int i = 0; i < times; ++i)
		{
			mtx.lock();
			++n;
			mtx.unlock();
		}
        //mtx.unlock();
		int end2 = clock();

		coastTime += (end2 - begin2);
		});

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

	cout << n << ":" << coastTime << endl; //打印n的值
	return 0;
}

锁外

锁内

我们的这种测试场景是很局限的，集中的对一个变量++，实际当中是不太可能出现的; 实际项目当中可能是在零散的位置统计多个线程整体走了多少次，使用原子的数据类型更好
constTime进行＋= 可能有安全隐患(出现问题的概率非常低)，不太可能暴露出来，最好要注意一下(atomic<int> coastTime)

互斥量mutex

1.mutex的种类

(1)std::mute

①mutex锁是C++11提供的最基本的互斥量，mutex对象之间不能进行拷贝，也不能进行移动。

②mutex中常用的成员函数

成员函数	功能
lock	对互斥量进行加锁
try_lock	尝试对互斥量进行加锁
unlock	对互斥量进行解锁，释放互斥量的所有权

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

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

④线程调用try_lock时，类似也可能会发生以下三种情况：

如果该互斥量当前没有被其他线程锁住，则调用线程将该互斥量锁住，直到调用unlock之前，该线程一致拥有该锁。
如果该互斥量已经被其他线程锁住，则try_lock调用返回false，当前的调用线程不会被阻塞。
如果该互斥量被当前调用线程锁住，则会产生死锁（deadlock）。

(2)std::recursive_mutex

recursive_mutex叫做递归互斥锁，该锁专门用于递归函数中的加锁操作。
如果在递归函数中使用mutex互斥锁进行加锁，那么在线程进行递归调用时，可能会重复申请已经申请到但自己还未释放的锁，进而导致死锁问题。
而recursive_mutex允许同一个线程对互斥量多次上锁（即递归上锁），来获得互斥量对象的多层所有权，但是释放互斥量时需要调用与该锁层次深度相同次数的unlock。
除此之外，recursive_mutex也提供了lock、try_lock和unlock成员函数，其的特性与mutex大致相同。

(3)std::timed_mutex

timed_mutex中提供了以下两个成员函数：

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

除此之外，timed_mutex也提供了lock、try_lock和unlock成员函数，其的特性与mutex相同。

(4)std::recursive_timed_mutex

recursive_timed_mutex就是recursive_mutex和timed_mutex的结合，recursive_timed_mutex既支持在递归函数中进行加锁操作，也支持定时尝试申请锁。

2.lock_guard和unique_lock

(1)使用互斥锁时可能出现的问题

①测试代码

void func(vector<int>& v, int n, int base, mutex& mtx)
{
	try
	{
		for (int i = 0; i < n; ++i)
		{
			mtx.lock();

			cout << this_thread::get_id() << ":" << base + i << endl;
			v.push_back(base + i); //push_back()失败了抛异常

			//模拟push_back失败抛异常
			if (base == 1000 && i == 888)
				throw bad_alloc();

			 mtx.unlock();
		}
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
}

int main()
{
	thread t1, t2;
	vector<int> vec;
	mutex mtx;

	try
	{
		t1 = thread(func, std::ref(vec), 1000, 1000, std::ref(mtx));
		t2 = thread(func, std::ref(vec), 1000, 2000, std::ref(mtx));
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

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

	return 0;
}

②测试结果

③实验解释

push_back() 失败是会抛异常的，可能是空间不足问题，这种问题很难出现，于是我们手动模拟在特定条件抛异常
push_back()之前我们是加锁的，抛出异常之后程序就跑到catch里面捕获异常了，此时互斥锁还没有释放。
我们看到的结果是程序卡主，一个线程拿着锁但是不执行，另一个线程拿不到锁无法执行，就造成了死锁
因此使用互斥锁时如果控制不好就会造成死锁，最常见的是锁在中间代码返回，此外还有一个比较常见的情况就是在锁的范围内抛异常，也很容易导致死锁问题

(2)lock_guard

C++11采用RAII的方式对锁进行了封装，于是就出现了lock_guard和unique_lock

①lock_guard是C++11中的一个模板类

template <class Mutex>
class lock_guard;

②lock_guard类模板主要是通过RAII的方式，对其管理的互斥锁进行了封装。

在需要加锁的地方，用互斥锁实例化一个lock_guard对象，在lock_guard的构造函数中会调用lock进行加锁。
当lock_guard对象出作用域前会调用析构函数，在lock_guard的析构函数中会调用unlock自动解锁。
通过这种构造对象时加锁，析构对象时自动解锁的方式就有效的避免了死锁问题

void func(vector<int>& v, int n, int base, mutex& mtx)
{
	try
	{
		for (int i = 0; i < n; ++i)
		{
			lock_guard<mutex> lg(mtx);
			cout << this_thread::get_id() << ":" << base + i << endl;
			v.push_back(base + i); //push_back()失败了抛异常

			//模拟push_back失败抛异常
			if (base == 1000 && i == 888)
				throw bad_alloc();
		}
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
}

③从lock_guard对象定义到该对象析构，这段区域的代码都属于互斥锁的保护范围。

如果只想用lock_guard保护某一段代码，可以通过定义匿名的局部域来控制lock_guard对象的生命周期

mutex mtx;
void func()
{
	//...
	//匿名局部域
	{
		lock_guard<mutex> lg(mtx); //调用构造函数加锁

		//Do something
        return; //调用析构函数解锁
        
	} //调用析构函数解锁
	//...
}

int main()
{
	func();
	return 0;
}

(3)模拟实现lock_guard

lock_guard类中包含一个锁成员变量（引用类型），这个锁就是每个lock_guard对象管理的互斥锁。
调用lock_guard的构造函数时需要传入一个被管理互斥锁，用该互斥锁来初始化锁成员变量后，调用互斥锁的lock函数进行加锁。
lock_guard的析构函数中调用互斥锁的unlock进行解锁。
需要删除lock_guard类的拷贝构造和拷贝赋值，因为lock_guard类中的锁成员变量本身也是不支持拷贝的。

namespace XM
{
	template<class Mutex>
	class lock_guard
	{
	public:
		lock_guard(Mutex& mtx)
			:_mtx(mtx)
		{
			mtx.lock(); //加锁
		}

		~lock_guard()
		{
			mtx.unlock(); //解锁
		}

		lock_guard(const lock_guard&) = delete;
		lock_guard& operator=(const lock_guard&) = delete;
	private:
		Mutex& _mtx;
	};
}

3.unique_lock

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

②unique_lock与lock_guard类似，unique_lock类模板也是采用RAII的方式对锁进行了封装。在创建unique_lock对象调用构造函数时也会调用lock进行加锁，在unique_lock对象销毁调用析构函数时也会调用unlock进行解锁。

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

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

④如下场景就适合使用unique_lock：

要用互斥锁保护函数1的大部分代码，但是中间有一小块代码调用了函数2，而调用函数2时不需要用函数1中的互斥锁进行保护，函数2内部的代码由其他互斥锁进行保护。
因此在调用函数2之前需要对当前互斥锁进行解锁，当函数2调用返回后再进行加锁，这样当调用函数2时其他线程调用函数1就能够获取到这个锁。

原子性操作库

1.线程安全问题

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

void func(int& n, int times)
{
	for (int i = 0; i < times; i++)
	{
		n++;
	}
}
int main()
{
	int n = 0;
	int times = 100000; //每个线程对n++的次数
	thread t1(func, ref(n), times);
	thread t2(func, ref(n), times);

	t1.join();
	t2.join();
	cout << n << endl; //打印n的值
	return 0;
}

①代码中分别让两个线程对同一个变量n进行了100000次 ++ 操作，理论上最终n的值应该是200000，但最终打印出n的值却是小于200000的。

②根本原因就是 ++ 操作并不是一个原子操作，该操作分为三步：

load ：将共享变量n从内存加载到寄存器中。
update ：更新寄存器里面的值，执行+1操作。
store ：将新值从寄存器写回共享变量n的内存地址。

③汇编代码

因此可能当线程1刚将n的值加载到寄存器中就被切走了，也就是只完成了++操作的第一步，而线程2可能顺利完成了一次完整的++操作才被切走，而这时线程1继续用之前加载到寄存器中的值完成剩余的两步操作，最终就会导致两个线程分别对共享变量n进行了一次++操作，但最终n的值却只被++了一次。
在这三条汇编指令执行期间，在任意一条都有可能被切换走

2.解决线程安全问题

(1)加锁解决线程安全问题

void func(int& n, int times, mutex& mtx)
{
	mtx.lock();
	for (int i = 0; i < times; i++)
	{
		//mtx.lock();
		n++;
		//mtx.unlock();
	}
	mtx.unlock();
}

这里可以选择在for循环体里面进行加锁解锁，也可以选择在for循环体外进行加锁解锁。但效果终究是不尽人意的，在for循环体里面进行加锁解锁会导致线程的频繁进行加锁解锁操作，在for循环体外面进行加锁解锁会导致两个线程的执行逻辑变为串行，而且如果锁控制得不好，还容易造成死锁。

(2)原子类解决线程安全问题

①C++11中引入了原子操作类型，使得线程间数据的同步变得非常高效

原子类型名称	对应的内置类型名称
atomic_bool	bool
atomic_char	char
atomic_schar	signed char
atomic_uchar	unsigned char
atomic_int	int
atomic_uint	unsigned int
atomic_short	short
atomic_ushort	unsigned short
atomic_long	long
atomic_ulong	unsigned long
atomic_llong	long long
atomic_ullong	unsigned long long
atomic_char16_t	char16_t
atomic_char32_t	char32_t
atomic_wchar_t	wchar_t

②程序员不需要对原子类型进行加锁解锁操作，线程能够对原子类型变量互斥访问

void func(atomic_int& n, int times)
{
	for (int i = 0; i < times; i++)
	{
		n++;
	}
}

int main()
{
	atomic_int n = { 0 };
	int times = 100000; //每个线程对n++的次数

	thread t1(func, ref(n), times);
	thread t2(func, ref(n), times);

	t1.join();
	t2.join();
	cout << n << endl; //打印n的值
	return 0;
}

③也可以使用atomic类模板定义出任意原子类型

void func(atomic<int>& n, int times)
{
	for (int i = 0; i < times; i++)
	{
		n++;
	}
}

int main()
{
	atomic<int> n = 0;
	int times = 100000; //每个线程对n++的次数
	thread t1(func, ref(n), times);
	thread t2(func, ref(n), times);

	t1.join();
	t2.join();
	cout << n << endl; //打印n的值
	return 0;
}

④补充

原子类型通常属于“资源类型”数据，多个线程只能访问单个原子类型的拷贝，因此在C++11中，原子类型只能从其模板参数中进行构造，不允许原子类型进行拷贝构造、移动构造以及operator=等。
为了防止意外，标准库已经将atomic模板类中的拷贝构造、移动构造、operator=默认删除掉了。
原子类型不仅仅支持原子的++操作，还支持原子的- -、加一个值、减一个值、与、或、异或操作。

条件变量库（condition_variable）

1.wait系列成员函数

(1)wait系列成员函数的作用就是让调用线程进行阻塞等待，包括wait , wait_for , wait_until

①以wait为例进行介绍，wait函数提供了两个不同版本的接口

//版本一
void wait(unique_lock<mutex>& lck);

//版本二
template<class Predicate>
void wait(unique_lock<mutex>& lck, Predicate pred);

②函数说明：

调用第一个版本的wait函数时只需要传入一个互斥锁，线程调用wait后会立即被阻塞，直到被唤醒。
调用第二个版本的wait函数时除了需要传入一个互斥锁，还需要传入一个返回值类型为bool的可调用对象，与第一个版本的wait不同的是，当线程被唤醒后还需要调用传入的可调用对象，如果可调用对象的返回值为false，那么该线程还需要继续被阻塞。

(2)为什么调用wait系列函数时需要传入一个互斥锁？

因为wait系列函数一般是在临界区中调用的，为了让当前线程调用wait阻塞时其他线程能够获取到锁，因此调用wait系列函数时需要传入一个互斥锁，当线程被阻塞时这个互斥锁会被自动解锁，而当这个线程被唤醒时，又会自动获得这个互斥锁。
因此wait系列函数实际上有两个功能，一个是让线程在条件不满足时进行阻塞等待，另一个是让线程将对应的互斥锁进行解锁。

(3)wait_for和wait_until函数的使用方式与wait函数类似

wait_for函数也提供了两个版本的接口，只不过这两个版本的接口都比wait函数对应的接口多了一个参数，这个参数是一个时间段，表示让线程在该时间段内进行阻塞等待，如果超过这个时间段则线程被自动唤醒。
wait_until函数也提供了两个版本的接口，只不过这两个版本的接口都比wait函数对应的接口多了一个参数，这个参数是一个具体的时间点，表示让线程在该时间点之前进行阻塞等待，如果超过这个时间点则线程被自动唤醒。
线程调用wait_for或wait_until函数在阻塞等待期间，其他线程调用notify系列函数也可以将其唤醒。此外，如果调用的是wait_for或wait_until函数的第二个版本的接口，那么当线程被唤醒后还需要调用传入的可调用对象，如果可调用对象的返回值为false，那么当前线程还需要继续被阻塞。
调用wait系列函数时，传入互斥锁的类型必须是unique_lock。

2.notify系列成员函数

notify_one：唤醒等待队列中的首个线程，如果等待队列为空则什么也不做。
notify_all：唤醒等待队列中的所有线程，如果等待队列为空则什么也不做。
注意：条件变量下可能会有多个线程在进行阻塞等待，这些线程会被放到一个等待队列中进行排队。

尝试用两个线程交替打印1-100的数字，要求一个线程打印奇数，另一个线程打印偶数

1.题目主要考察线程的同步和互斥

互斥：两个线程都在向控制台打印数据，为了保证两个线程的打印数据不会相互影响，因此需要对线程的打印过程进行加锁保护。
同步：两个线程必须交替进行打印，因此需要用到条件变量让两个线程进行同步，当一个线程打印完再唤醒另一个线程进行打印。

2.只有同步和互斥是无法满足题目要求

首先，我们无法保证哪一个线程会先进行打印，不能说先创建的线程就一定先打印，后创建的线程先打印也是有可能的。(线程的运行为了保证公平，不被饿死是基于时间片轮转的)
此外，有可能会出现某个线程连续多次打印的情况，比如线程1先创建并打印了一个数字，当线程1准备打印第二个数字的时候线程2可能还没有创建出来，或是线程2还没有在互斥锁上进行等待，这时线程1就会再次获取到锁进行打印。

3.这里还需要定义一个flag变量，该变量的初始值设置为true。

假设让线程1打印奇数，线程2打印偶数。那么就让线程1调用wait函数阻塞等待时，传入的可调用对象返回flag的值，而让线程2调用wait函数阻塞等待时，传入的可调用对象返回!flag的值。
由于flag的初始值是true，就算线程2先获取到互斥锁也不能进行打印，因为最开始线程2调用wait函数时，会因为可调用对象的返回值为false而被阻塞，这就保证了线程1一定先进行打印。
为了让两个线程交替进行打印，因此两个线程每次打印后都需要更改flag的值，线程1打印完后将flag的值改为false并唤醒线程2，这时线程2被唤醒时其可调用对象的返回值就变成了true，这时线程2就可以进行打印了。
当线程2打印完后再将flag的值改为true并唤醒线程1，这时线程1就又可以打印了，就算线程2想要连续打印也不行，因为如果线程1不打印，那么线程2的可调用对象的返回值就一直为false，对于线程1也是一样的道理。

int main()
{
	int n = 100;
	mutex mtx;
	condition_variable cv;
	bool flag = true;

	//奇数
	thread t1([&]{
		int i = 1;
		while (i <= 100)
		{
			unique_lock<mutex> ul(mtx);
			cv.wait(ul, [&flag]()->bool{return flag; }); //等待条件变量满足
			cout << this_thread::get_id() << ":" << i << endl;
			i += 2;
			flag = false;
			cv.notify_one(); //唤醒条件变量下等待的一个线程
		}
	});

	//偶数
	thread t2([&]{
		int j = 2;
		while (j <= 100)
		{
			unique_lock<mutex> ul(mtx);
			cv.wait(ul, [&flag]()->bool{return !flag; }); //等待条件变量满足
			cout << this_thread::get_id() << ":" << j << endl;
			j += 2;
			flag = true;
			cv.notify_one(); //唤醒条件变量下等待的一个线程
		}
	});

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