进程线程笔记

第一节 并发基本概念及实现，进程、线程基本概念

并发、进程、线程的基本概念和综述

• 并发：
   有两个或两个以上的任务（独立的活动），同时发生（进行），或者说一个程序同时执行多个独立任务。
  当cpu的数量少于任务数的时候，其实只是通过轮流调度来实现一种表面的并发进行。
  使用并发的原因：可以同时执行多个任务，提高性能
• 进程：
   可以理解为一个正在执行的可执行程序。
• 线程：
   每个进程都有一个主线程，可以理解为代码的执行通路，我们可以写代码来创建其它线程，就可以实现，在同一个时间，在同一个进程执行多个任务
   线程并非越多越好，线程切换也是需要时间的，需要保存恢复各种局部变量。（一般200~300个为佳）
• 多进程并发与多线程并发
   多进程实现并发相比于多线程实现并发而言，它还需要切换虚拟地址空间，开销更大。
   多进程之间通信需要借助管道、文件、消息队列、共享内存、socket等技术手段
   多线程之间他们是共享一个虚拟地址空间的，即可以共享内存，线程间切换开销更小，但需要解决的一个重要问题就是：要保证数据一致性
• 以往在不同的开发平台上进行多线程开发都有不同的库、不同的函数，因此编写出来的程序一般不能跨平台。从c++11新标准开始，c++语言本身增加了对多线程的支持，使得编写的程序有了可移植性

第二节 线程启动、结束，创建线程多法、join，detach

一、范例演示线程运行的开始
1、需注意知识点：
  程序运行起来，生成一个进程，该进程所属的主线程开始自动运行；当主线程从main()函数返回，则整个进程执行完毕
  主线程从main()开始执行，那么我们自己创建的线程，也需要从一个函数开始运行（初始函数），一旦这个函数运行完毕，线程也结束运行
  整个进程是否执行完毕的标志是：主线程是否执行完，如果主线程执行完毕了，就代表整个进程执行完毕了，此时如果其他子线程还没有执行完，也会被强行终止【此条有例外，以后会解释】
2、创建一个线程：
  包含头文件thread
  写初始函数
  在main中创建thread
注意：有两个线程在跑，相当于整个程序中有两条线在同时走，即使一条被阻塞，另一条也能运行
1）join(): join意为汇合，子线程和主线程汇合,阻塞主线程并等待子线程执行完，当子线程执行完毕，join()就执行完毕，主线程继续往下执行
2)detach(): 传统多线程要等待子线程执行完毕之后自己才可以退出。detach（分离）可以打破这个规则，主线程与子线程不用再汇合，各自执行各自的。
  引入detach原因是：创建子线程过多的时候，让主线程等待子线程不太ok。但是主线程不等的话会很容易导致程序不稳定，不太可靠。
  detach之后，与主线程关联的子线程就会分离，此时这个子线程就会滞留在后台运行（即主线程与该子线程失去联系），该子线程被C++运行时库接管，其运行完成后，相关资源由运行时库清理。驻留在后台的线程也叫守护线程。
  一旦detach()就不能再把该子线程join(),否则会弹出异常
3）joinable(): 判断是否可以成功使用join()或者detach()，返回true、false
  如果返回true，则可以调用join()或者detach()
  如果返回false，则调用过join()或者detach()，join()和detach()都不能再调用了

#include <iostream>
#include <thread>
using namespace std;
void myprint()
{
	cout << "线程开始执行" << endl;
	//...
	//...
	cout << "线程执行结束1" << endl;
	cout << "线程执行结束2" << endl;
	cout << "线程执行结束3" << endl;
	cout << "线程执行结束4" << endl;
	cout << "线程执行结束5" << endl;
	cout << "线程执行结束6" << endl;
	cout << "线程执行结束7" << endl;
	cout << "线程执行结束8" << endl;
}
int main()
{
	//(1)创建了线程，线程执行起点（入口）是myPrint；(2)执行线程
	thread mytobj(myprint);

	//(2)阻塞主线程并等待子线程执行完，当myPrint执行完毕，join()就执行完毕，主线程继续往下执行
	//join意为汇合，子线程和主线程汇合
	//mytobj.join();
	mytobj.detach();

	//joinable()判断是否可以成功使用join()或者detach()
		//如果返回true，证明可以调用join()或者detach()
		//如果返回false，证明调用过join()或者detach()，join()和detach()都不能再调用了
	if (mytobj.joinable())
	{
		cout << "可以调用join()或者detach()" << endl;
	}
	else
	{
		cout << "不能调用join()或者detach()" << endl;
	}
	cout << "主线程收尾，最终主线程安全正常退出" << endl;
	return 0;
}

结果：
只用join():

注释掉join():没汇合，主线程可能会在子线程还未执行完毕时就退出，导致异常。

使用detach():子线程与主线程分离，失去关联。
使用joinable()判断是否还能使用jion()、detach():

注意：线程类参数是一个可调用对象。
  一组可执行的语句称为可调用对象，c++中的可调用对象可以是函数、函数指针、lambda表达式、bind创建的对象或者重载了函数调用运算符的类对象。

二、其他创建线程的方法
①创建一个类，并编写圆括号重载函数，初始化一个该类的对象，把该对象作为线程入口地址

#include <iostream>
#include <thread>
using namespace std;
class obj
{
public:
	void operator()()//暂时不带参数   线程入口点
	{
		cout << "线程开始执行" << endl;
		//...
		cout << "线程执行结束1" << endl;
	}
};
int main()
{
	obj ob;
	thread mytobj(ob);
	mytobj.join();
	cout << "hhh" << endl;
	return 0;
}

//类内声明了变量的情况
class obj
{
public:
	int &m_i1;//&m_i1,&m用了&，detach程序会出问题，去掉引用才可以detach
	obj(int &m) :m_i1(m) {}
	void operator()()//暂时不带参数   线程入口点
	{
		cout << "线程开始执行" << endl;
		//...
		//m是主函数的局部变量的引用，当主线程执行完毕之后，局部变量被释放，此时访问m_i1,结果不可预料
		cout << "m_i1  1"<<m_i1 << endl;
		cout << "m_i1  2" << m_i1 << endl;
		cout << "m_i1  3" << m_i1 << endl;
		cout << "m_i1  4" << m_i1 << endl;
		cout << "m_i1  5" << m_i1 << endl;
		cout << "m_i1  6" << m_i1 << endl;
	}
};
int main()
{
	int m = 2;
	obj ob(m);
	//主线程运行结束后，m被释放，会产生不可预料后果，那对象ob也被释放了啊？子线程为什么还存在？
	//原因：对象ob是被 复制 到线程中去的，主线程中的ob被释放，但是线程中的obj对象还存在。但是如果这个对象使用了指针引用之类的，依旧会存在问题
	//可以自己写一个拷贝构造函数证明，此处复制
	thread mytobj(ob);
	mytobj.detach();
	cout << "hhh" << endl;
	return 0;
}

②lambda表达式创建线程

int main()
{
	auto lambdaThread = [] {
		cout << "我的线程开始执行了" << endl;
		//-------------
		//-------------
		cout << "我的线程开始执行了" << endl;
	};
	thread myThread(lambdaThread);
	myThread.join();
	cout<<"hhh"<<endl;
	return 0;
}

第三节 线程传参详解，detach()大坑，成员函数做线程函数

一、传递临时对象作为线程参数

• 陷阱一：

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

//void myPrint(const int &i, char* pmybuf)
void myPrint(const int i,const string& pmybuf)
{
	//如果线程从主线程detach了
	//i不是mvar真正的引用，实际上值传递，即使主线程运行完毕了，子线程用i仍然是安全的，但仍不推荐传递引用
	//推荐改为const int i
	cout << i << endl;
	//pmybuf还是指向原来的字符串，所以这么写是不安全的
	//那要怎么传入字符串呢？
	//传入的参数可以改成string&,因为类型不一样，char*转为string&,就一定是值传递，主线程子线程使用的字符串就不是同一个字符串了，但是否安全了呢？
	cout << pmybuf.c_str() << endl;
}

int main()
{
	int mvar = 1;
	int& mvary = mvar;//这里是引用，detach()就会有问题，只要用detach就一定不用指针引用，指针一定会有问题
	char mybuf[] = "this is a test";
	thread myThread(myPrint, mvar, mybuf);//第一个参数是函数名，后两个参数是函数的参数
	//myThread.join();
	myThread.detach();

	cout << "hhh" << endl;
}

• 陷阱二：

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

//void myPrint(const int &i, char* pmybuf)
void myPrint(const int i,const string& pmybuf)
{
	cout << i << endl;
	//pmybuf还是指向原来的字符串，所以这么写是不安全的
	//那要怎么传入字符串呢？
	//传入的参数可以改成string&,因为类型不一样，char*转为string&,就一定是值传递，主线程子线程使用的字符串就不是同一个字符串了
	//但安全了吗？mybuf是在什么时候转成string类型的呢？主线程结束后，还没复制不也就出问题了吗？
	cout << pmybuf.c_str() << endl;
}

int main()
{
	int mvar = 1;
	int& mvary = mvar;//这里是引用，detach()就会有问题，只要用detach就一定不用指针引用，指针一定会有问题
	char mybuf[] = "this is a test";
	thread myThread(myPrint, mvar, mybuf);//第一个参数是函数名，后两个参数是函数的参数
										  //事实上，存在mian()函数执行完毕之后，系统才用mybuf去转为string的可能性。那要怎么改呢？
	//最终版本:thread myThread(myPrint, mvar, string(mybuf));
	//这里的string(mybuf))会调用两次拷贝构造函数，惊不惊喜，意不意外！说明thread内部用很粗暴的方式保证子线程使用的变量与主线程只是值一样。

	//myThread.join();
	myThread.detach();
	cout << "hhh" << endl;
}

• 总结
  如果传递int这种简单类型，推荐使用值传递，不要用引用
  如果传递类对象，避免使用隐式类型转换，全部都在创建线程这一行就创建出临时对象，然后在函数参数里，用引用来接，否则还会创建出一个对象（那就是三个对象了，很浪费）。
  终极结论：建议不使用detach

二、临时对象作为线程参数继续讲

• 1、线程id概念
    id是个数字，每个线程（不管是主线程还是子线程）实际上都对应着一个数字，而且每个线程对应的这个数字都不一样
    线程id可以用C++标准库里的函数来获取。std::this_thread::get_id()来获取
• 2、临时对象构造时机抓捕

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

class A
{
public:
	int ma;
	A(int m) :ma(m) {
		cout << "A构造函数执行" << this << "  线程id=" << std::this_thread::get_id() << endl;
	}
	A(const A& a):ma(a.ma)
	{
		cout << "A拷贝构造函数执行" << this<<"  线程id="<<std::this_thread::get_id()<<endl;
	}
	~A()
	{
		cout << "A析构函数执行" << this << "  线程id=" << std::this_thread::get_id() << endl;
	}
};

void myPrint2(const A& mybuf)
{
	cout << "子线程myPrint2的参数地址是" << &mybuf << "  thread = " << std::this_thread::get_id() << endl;
}
int main()
{
	cout << "主线程id = " << std::this_thread::get_id() << endl;
	int mvar = 1;
	thread myThread(myPrint2, mvar);//将这里改成thread myThread(myPrint2, A(mvar)),会发现在主线程临时对象就会先被构造出来，避免出错

	myThread.join();
	//myThread.detach();
	cout << "hhh" << endl;
	return 0;
}

thread myThread(myPrint2, mvar)的结果：

thread myThread(myPrint2, A(mvar))的结果：

由结果可知，临时对象是在线程中构造的，也就是说，detach之后，一旦主线程在子线程执行完之后再构造临时对象，就会出错

用成员函数指针做线程函数

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


class A
{
public:
	int ma;
	A(int m) :ma(m) {
		cout << "A构造函数执行" << this << "  线程id=" << std::this_thread::get_id() << endl;
	}
	A(const A& a):ma(a.ma)
	{
		cout << "A拷贝构造函数执行" << this<<"  线程id="<<std::this_thread::get_id()<<endl;
	}
	~A()
	{
		cout << "A析构函数执行" << this << "  线程id=" << std::this_thread::get_id() << endl;
	}
	void thread_work(int num)
	{
		cout << "用类的普通成员作为线程入口：" << "  线程id=" << std::this_thread::get_id() << endl;
	}
};

int main()
{
	cout << "主线程id = " << std::this_thread::get_id() << endl;
	A myob(10);
	thread myth(&A::thread_work, myob, 13);//13是thread_work的参数
	myth.join();
	cout << "hhh" << endl;
	return 0;
}

第四节 创建多个线程、数据共享问题分析、案例代码

一、创建和等待多个线程

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

void TextThread()
{
	cout << "线程--" << this_thread::get_id() << "开始执行" << endl;
	/*  …  */
	cout << "线程--" << this_thread::get_id() << "执行结束" << endl;
}

int main()
{
	vector<thread> mu_thread;
	for (int i = 0; i < 10; ++i)
	{
		mu_thread.push_back(thread(TextThread));
	}
	for (int i = 0; i < 10; ++i)
	{
		mu_thread[i].join();
	}
	return 0;
}

• 把thread对象放入到容器中管理，看起来像个thread对象数组，对一次创建大量的线程并对大量线程进行管理有好处
• 多个线程执行顺序是乱的，跟操作系统内部对线程的运行调度机制有关

二、数据共享问题分析

• 只读的数据
   是安全稳定的
• 有读有写
    若不加处理，就会出错
   最简单的防止崩溃方法：读的时候不能写，写的时候不能读。

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

class A {
public:
	//添加数据：写
	void inmass()
	{
		for (int i = 0; i < 1000; i++)
		{
			cout << "inmass()执行,插入元素" << i << endl;
			masslist.push_back(i);
		}
	}
	//取数据：读、写
	void outmass()
	{
		for (int i = 0; i < 1000; i++)
		{
			if (!masslist.empty())
			{
				int com = masslist.front();
				masslist.pop_front();
			}
			else {
				cout << "outmass()执行,消息队列为空！" << endl;
			}
		}
	}

private:
	list<int> masslist;
};

int main()
{
	A myobj;
	thread inthread(&A::inmass, &myobj);
	thread outthread(&A::outmass, &myobj);
	inthread.join();
	outthread.join();
	return 0;
}
//这个代码会崩，没有对共享数据进行保护

第五节 互斥量概念、用法、死锁演示及解决详解

一、互斥量（mutex）的基本概念
  互斥量就是个类对象，可以理解为一把锁，多个线程尝试用lock()成员函数来加锁，只有一个线程能锁定成功，如果没有锁成功，那么流程将卡在lock()这里不断尝试去锁定。
  互斥量使用程序员自己确定，少用了达不到效果，多了影响效率。

二、互斥量的用法

• 包含#include <mutex>头文件
• lock()，unlock()
     步骤：1.lock()，2.操作共享数据，3.unlock()。
     lock()和unlock()要成对使用
• lock_guard类模板
     lock_guard<mutex> sbguard(myMutex);取代lock()和unlock(),使用了lock_guard之后，就不能再使用lock与unlock;
     lock_guard构造函数执行了mutex::lock();在作用域结束时，调用析构函数，执行mutex::unlock()

三、死锁

• 死锁演示
   死锁至少有两个互斥量1，2。
  a.线程A执行时，先锁1，并且锁成功，但在锁2的时候，线程调度，出现了上下文切换，开始执行线程B。
  b.线程B执行，先锁2，2没有被线程A上锁，即2可以被锁成功，然后线程B要去锁1.
  c.产生死锁，A锁着1，需要锁2，B锁着2，需要锁1，互相等着对方释放锁，两个线程没办法继续运行。

• 死锁的一般解决方案：
   保证多个互斥量上锁的顺序一样。

• std::lock()函数模板
  std::lock(mutex1,mutex2……); 一次锁定多个互斥量（一般这种情况很少），用于处理多个互斥量。
  如果互斥量中一个没锁住，它就等着，等所有互斥量都锁住，才能继续执行。如果有一个没锁住，就会把已经锁住的释放掉（要么互斥量都锁住，要么都没锁住，防止死锁）

• std::lock_guard的std::adopt_lock参数
  std::lock_guardstd::mutex my_guard(my_mutex,std::adopt_lock);
  加入adopt_lock后，在调用lock_guard的构造函数时，不再进行lock();
  adopt_guard为结构体对象，起一个标记作用，表示这个互斥量已经lock()，不需要在lock()。

第六节 unique_lock（类模板）详解

一、unique_lock取代lock_guard
   unique_lock比lock_guard灵活很多（多出来很多用法），效率差一点。
   unique_lock<mutex> myUniLock(myMutex);

二、unique_lock的第二个参数

• std::adopt_lock：
    表示这个互斥量已经被lock()，即不需要在构造函数中lock这个互斥量了。(与lock_guard一致)
   前提：必须提前lock
    lock_guard中也可以用这个参数
• std::try_to_lock：
   尝试用mutex的lock()去锁定这个mutex，但如果没有锁定成功，会立即返回，不会阻塞在那里；
   使用try_to_lock的原因是防止其他的线程锁定mutex太长时间，导致本线程一直阻塞在lock这个地方
   前提：不能提前lock();
   owns_locks()方法判断是否拿到锁，如拿到返回true
• std::defer_lock：
   如果没有第二个参数就对mutex进行加锁，加上defer_lock是始化了一个没有加锁的mutex
   不给它加锁的目的是以后可以调用unique_lock的一些方法
   前提：不能提前lock
  三、unique_lock的成员函数（前三个与std::defer_lock联合使用）
• lock()：加锁。
• unlock()：解锁，unique_lock可以自己解锁，还提供这个unlock()的原因是,因为一些非共享代码要处理，可以暂时先unlock()，用其他线程把它们处理了，处理完后再lock()。
• try_lock()：尝试给互斥量加锁,
   如果拿不到锁，返回false，否则返回true。

			unique_lock<mutex> unlo(mymutex1, defer_lock);
			if(unlo.try_lock())
			{
			//处理共享变量
			}

• release()：
   unique_lock<mutex> unlo(myyutex1);相当于把mymutex1和unlo绑定在了一起，release()就是解除绑定，返回它所管理的mutex对象的指针，并释放所有权
   mutex* ptx =unlo.release():所有权由ptx接管，如果原来mutex对象处理加锁状态，就需要ptx在以后进行解锁了。ptx->unlock().
• 注意：
   lock的代码段越少，执行越快，整个程序的运行效率越高。
   a.锁住的代码少，叫做粒度细，执行效率高；
   b.锁住的代码多，叫做粒度粗，执行效率低；

四、unique_lock所有权的传递
 unique_lock<mutex> unlo(mymutex1);把mymutex1和unlo绑定在了一起，也就是unlo拥有mymutex1的所有权

• 1、使用move转移
  unlo拥有mymutex1的所有权，unlo可以把自己对mymutex1的所有权转移，但是不能复制。
  unique_lock<mutex> unlo1(std::move(unlo));
  现在unlo1拥有mymutex1的所有权。
• 2、在函数中return一个临时变量，即可以实现转移

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

class A {
public:
	//返回锁的函数
	unique_lock<mutex> relock()
	{
		unique_lock<mutex> unlo(mymutex1);
		return unlo;//返回了临时对象
	}
	//添加数据：写
	void inmass()
	{
		for (int i = 0; i < 1000; i++)
		{
			cout << "inmass()执行,插入元素" << i << endl;
			unique_lock<mutex> unlo1 = relock();
			masslist.push_back(i);
		}
	}

	bool outMsgLULProc(int &com)
	{
		mymutex1.lock();
		if (!masslist.empty())
		{
			com = masslist.front();
			cout << com << endl;
			masslist.pop_front();
			mymutex1.unlock();
			return true;
		}
		mymutex1.unlock();
		return false;
	}

	//取数据：读、写
	void outmass()
	{
		int com = 0;
		for (int i = 0; i < 1000; i++)
		{
			bool result = outMsgLULProc(com);
			if (result)
			{
				cout << "outmass()执行,取出一个元素:";
			}
			else {
				cout << "outmass()执行,消息队列为空！" << endl;
			}
		}
	}
private:
	list<int> masslist;
	mutex mymutex1;
};

int main()
{
	A myobj;
	//mutex myMutex;
	thread inthread(&A::inmass, &myobj);
	thread outthread(&A::outmass, &myobj);
	inthread.join();
	outthread.join();
	return 0;
}

第七节 单例设计模式共享数据分析、解决，call_once

一、单例设计模式：
 整个项目中，有某个或者某些特殊的类，只能创建一个属于该类的对象。
 单例类：只能生成一个对象。

#include <iostream>
using namespace std;

/*
单例模式：
饿汉式：在类加载时就完成了初始化，所以类加载比较慢，但获取对象的速度快。
懒汉式：在类加载时不初始化，等到第一次被使用时才初始化。
这里用的是懒汉模式
*/

class Singelton
{
private:
	Singelton() {}
	static Singelton* mys;
public:
	static Singelton * getInstance() {
		//双重锁定 提高效率
		if (mys == NULL) {
			if (mys == NULL) {
				mys = new Singelton;
				static CG CG_huishou;
			}
		}
		return mys;
	}
	//类中套类，释放static指针
	class CG
	{
	public:
		~CG()
		{
			if (Singelton::mys)
			{
				delete Singelton::mys;
				Singelton::mys = NULL;
			}
		}
	};
};
Singelton* Singelton::mys = NULL;
int main()
{
	Singelton *s1 = Singelton::getInstance();
	Singelton *s2 = Singelton::getInstance();
	cout << s1 << "  " << s2 << endl;
	return 0;
}

二、单例设计模式共享数据分析、解决
 面临问题：需要在自己创建的线程中来创建单例类的对象，这种线程可能不止一个。此时，GetInstance()这种成员函数需要互斥。
 解决方法：可以在加锁前判断m_instance是否为空，否则每次调用Singelton::getInstance()都要加锁，十分影响效率。

三、std::call_once()：
  函数模板，该函数的第一个参数为标记，第二个参数是一个函数名（如a()）。
  功能：能够保证函数a()只被调用一次。具备互斥量的能力，而且比互斥量消耗的资源更少，更高效。
  call_once()需要与一个标记结合使用，这个标记为std::once_flag；once_flag是一个结构，call_once()就是通过标记来决定函数是否执行，调用成功后，就把标记设置为一种已调用状态。
  多个线程同时执行时，一个线程会等待另一个线程先执行。

once_flag g_flag;
class Singelton
{
public:
    static void CreateInstance()//call_once保证其只被调用一次
    {
        instance = new Singelton;
        static CG CG_huishou;
    }
    //两个线程同时执行到这里，其中一个线程要等另外一个线程执行完毕
	static Singelton * getInstance() {
         call_once(g_flag, CreateInstance);
         return instance;
	}
	class CG
	{
	public:
		~CG()
		{
			if (Singelton::mys)
			{
				delete Singelton::mys;
				Singelton::mys = NULL;
			}
		}
	};
private:
	Singelton() {}
	static Singelton *instance;
};
Singelton * Singelton::instance = NULL;

第八节 condition_variable、wait、notify_one、notify_all

一、条件变量condition_variable、wait、notify_one、notify_all
  std::condition_variable实际上是一个类，是一个和条件相关的类，说白了就是等待一个条件达成。

std::mutex mymutex1;
std::unique_lock<std::mutex> sbguard1(mymutex1);
std::condition_variable condition;
condition.wait(sbguard1, [this] {if (!msgRecvQueue.empty())
                                    return true;
                                return false;
                                });
condition.wait(sbguard1);

wait()用来等待
  如果第二个参数的lambda表达式返回值是false，那么wait()将解锁互斥量，并阻塞到本行
  如果第二个参数的lambda表达式返回值是true，那么wait()直接返回并继续执行。
  阻塞到什么时候为止呢？阻塞到其他某个线程调用notify_one()成员函数为止；
  如果没有第二个参数，那么效果跟第二个参数lambda表达式返回false效果一样
  wait()将解锁互斥量，并阻塞到本行，阻塞到其他某个线程调用notify_one()成员函数为止。

当其他线程用notify_one()将本线程wait()唤醒后，这个wait恢复后：
  1、wait()不断尝试获取互斥量锁，如果获取不到那么流程就卡在wait()这里等待获取，如果获取到了，那么wait()就继续执行，获取到了锁
 如果wait有第二个参数就判断这个lambda表达式。
  a)如果表达式为false，那wait又对互斥量解锁，然后又休眠，等待再次被notify_one()唤醒
  b)如果lambda表达式为true，则wait返回，流程可以继续执行（此时互斥量已被锁住）。
 如果wait没有第二个参数，则wait返回，流程走下去。
  流程只要走到了wait()下面则互斥量一定被锁住了。

#include <thread>
#include <iostream>
#include <list>
#include <mutex>
using namespace std;
 
class A {
public:
    void inMsgRecvQueue() {
        for (int i = 0; i < 100000; ++i) 
        {
            cout << "inMsgRecvQueue插入一个元素" << i << endl;

            std::unique_lock<std::mutex> sbguard1(mymutex1);
            msgRecvQueue.push_back(i); 
            //尝试把wait()线程唤醒,执行完这行，
            //那么outMsgRecvQueue()里的wait就会被唤醒
            //只有当另外一个线程正在执行wait()时notify_one()才会起效，否则没有作用
            condition.notify_one();
        }
	}
 
	void outMsgRecvQueue() {
        int command = 0;
        while (true) {
            std::unique_lock<std::mutex> sbguard2(mymutex1);
            // wait()用来等一个东西
            // 如果第二个参数的lambda表达式返回值是false，那么wait()将解锁互斥量，并阻塞到本行
            // 阻塞到什么时候为止呢？阻塞到其他某个线程调用notify_one()成员函数为止；
            //当 wait() 被 notify_one() 激活时，会先执行它的 条件判断表达式 是否为 true，
            //如果为true才会继续往下执行
            condition.wait(sbguard2, [this] {
                if (!msgRecvQueue.empty())
                    return true;
                return false;});
            command = msgRecvQueue.front();
            msgRecvQueue.pop_front();
            //因为unique_lock的灵活性，我们可以随时unlock，以免锁住太长时间
            sbguard2.unlock(); 
            cout << "outMsgRecvQueue()执行，取出第一个元素" << endl;
        }
	}
 
private:
	std::list<int> msgRecvQueue;
	std::mutex mymutex1;
	std::condition_variable condition;
};
 
int main() {
	A myobja;
	std::thread myoutobj(&A::outMsgRecvQueue, &myobja);
	std::thread myinobj(&A::inMsgRecvQueue, &myobja);
	myinobj.join();
	myoutobj.join();
}

二、深入思考
上面的代码可能导致出现一种情况：
  因为outMsgRecvQueue()与inMsgRecvQueue()并不是一对一执行的，所以当程序循环执行很多次以后，可能在msgRecvQueue 中已经有了很多消息，但是，outMsgRecvQueue还是被唤醒一次只处理一条数据。这时可以考虑把outMsgRecvQueue多执行几次，或者对inMsgRecvQueue进行限流。
三、notify_all()
  notify_one()：通知一个线程的wait()
  notify_all()：通知所有线程的wait()

第九节、async、future、packaged_task、promise

一、std::async、std::future创建后台任务并返回值
  std::async是一个函数模板，用来启动一个异步任务，启动起来一个异步任务之后，它返回一个std::future对象，这个对象是个类模板。
  什么叫“启动一个异步任务”？就是自动创建一个线程，并开始 执行对应的线程入口函数，它返回一个std::future对象，这个std::future对象中就含有线程入口函数所返回的结果，我们可以通过调用future对象的成员函数get()来获取结果。
  也有人称呼std::future提供了一种访问异步操作结果的机制，就是说这个结果你可能没办法马上拿到，但是这个线程执行完毕时，就能够拿到结果，所以，可以这么理解：future中保存着一个值，这个值是在将来的某个时刻能够拿到。
  std::future对象的get()成员函数会等待线程执行结束并返回结果，拿不到结果它就会一直等待，像可以获取结果的join()
  std::future对象的wait()成员函数，用于等待线程返回，本身并不返回结果，这个效果和 std::thread 的join()更像。

#include <iostream>
#include <future>
using namespace std;
class A {
public:
	int mythread(int mypar) {
		cout << mypar << endl;
		return mypar;
	}
};
 
 
int mythread() {
	cout << "mythread() start" << "threadid = " << std::this_thread::get_id() << endl;
	std::chrono::milliseconds dura(5000);
	std::this_thread::sleep_for(dura);
	cout << "mythread() end" << "threadid = " << std::this_thread::get_id() << endl;
	return 5;
}
 
 
int main() {
	A a;
	int tmp = 12;
	cout << "main" << "threadid = " << std::this_thread::get_id() << endl;
	std::future<int> result1 = std::async(mythread);
	//async(mythread)没有指定参数，默认参数为std::launch::async|std::lunch::deferred
	
	cout << "continue........" << endl;
	cout << result1.get() << endl; //卡在这里等待mythread()执行完毕，拿到结果
	
	//类成员函数
	std::future<int> result2 = std::async(&A::mythread, &a, tmp); //第二个参数是对象引用才能保证线程里执行的是同一个对象
	cout << result2.get() << endl;
   //或者result2.wait();
	cout << "good luck" << endl;
	return 0;
}

1、std::lunch::deferred（同步）：（defer推迟，延期）表示线程入口函数的调用会被延迟，一直到std::future的wait()或者get()函数被调用时（由主线程调用）才会执行；如果wait()或者get()没有被调用，则不会执行。
  实际上根本就没有创建新线程。std::lunch::deferred意思时延迟调用，并没有创建新线程，是在主线程中调用的线程入口函数。
2、std::launch::async（异步）：，在调用async函数的时候就开始创建新线程。

二、std::packaged_task：打包任务，把任务包装起来。
  类模板，它的模板参数是各种可调用对象，通过packaged_task把各种可调用对象包装起来，方便将来作为线程入口函数来调用

int main() {
	cout << "main" << "threadid = " << std::this_thread::get_id() << endl;
	std::packaged_task<int(int)> mypt([](int mypar) {
		cout << mypar << endl;
		cout << "mythread() start" << "threadid = " << std::this_thread::get_id() << endl;
		std::chrono::milliseconds dura(5000);
		std::this_thread::sleep_for(dura);
		cout << "mythread() end" << "threadid = " << std::this_thread::get_id() << endl;
		return 5;
	});//上面大括号内的是lambda表达式

	std::thread t1(std::ref(mypt), 1);
	t1.join();
	cout << "caicaikan" << endl;
	std::future<int> result = mypt.get_future();//这里只是保存了结果而已，线程早就建立了
	//std::future对象里包含有线程入口函数的返回结果，这里result保存mythread返回的结果。

	cout << result.get() << endl;

	cout << "good luck" << endl;
	return 0;
}

  packaged_task包装起来的可调用对象还可以直接调用，从这个角度来讲，packaged_task对象也是一个可调用对象
lambda的直接调用

int main() {
	cout << "main" << "threadid = " << std::this_thread::get_id() << endl;
	std::packaged_task<int(int)> mypt([](int mypar) {
		cout << mypar << endl;
		cout << "mythread() start" << "threadid = " << std::this_thread::get_id() << endl;
		std::chrono::milliseconds dura(5000);
		std::this_thread::sleep_for(dura);
		cout << "mythread() end" << "threadid = " << std::this_thread::get_id() << endl;
		return 5;
	});
//线程id一样，没有创建新线程
	mypt(1);
	std::future<int> result = mypt.get_future();
	cout << result.get() << endl;
}

std::promise，类模板
 我们能够在某个线程中给它赋值，然后我们可以在其他线程中，把这个值取出来

//promise类模板：我们能够在某个线程中给它赋值，然后我们可以在其他线程中，把这个值取出来
//可以通过promise实现线程间的通信
#include <thread>
#include <iostream>
#include <future>
using namespace std;

void mythread(std::promise<int> &tmp, int clac) {
	cout << "mythread() start" << "threadid = " << std::this_thread::get_id() << endl;
	std::chrono::milliseconds dura(5000);
	std::this_thread::sleep_for(dura);
	cout << "mythread() end" << "threadid = " << std::this_thread::get_id() << endl;
	int result = clac;
	tmp.set_value(result); //结果保存到了tmp这个对象中
	return;
}

void mythread2(std::future<int>& temf)
{
	auto result = temf.get();//get 只能调用一次，不能调用多次
	cout << "mythread2 result = " << result << endl;
}

int main() {
	std::promise<int> myprom;//将一个int型的结果保存到promise中
	std::thread t1(mythread, std::ref(myprom), 180);
	t1.join(); //在这里线程已经执行完了
	std::future<int> fu1 = myprom.get_future(); //promise和future绑定，用于获取线程返回值
	//auto result = fu1.get();//get 只能调用一次，不能调用多次
	//cout << "result = " << result << endl;
	std::thread t2(mythread2, std::ref(fu1));
	t2.join();
}

注意：使用thread时，必须 join() 或者 detach()， 否则程序会报异常

第十节 future其他成员函数、shared_future、atomic

一、std::future 的成员函数
  1、std::future_status status = result.wait_for(std::chrono::seconds(几秒));卡住当前流程，等待std::async()的异步任务运行一段时间，然后返回其状态std::future_status。如果std::async()的参数是std::launch::deferred（延迟执行），则不会卡住主流程。
  std::future_status是枚举类型，表示异步任务的执行状态。类型的取值有

std::future_status::timeout
std::future_status::ready
std::future_status::deferred

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

int mythread() {
	cout << "mythread() start" << "threadid = " << std::this_thread::get_id() << endl;
	std::chrono::milliseconds dura(5000);
	std::this_thread::sleep_for(dura);
	cout << "mythread() end" << "threadid = " << std::this_thread::get_id() << endl;
	return 5;
}

int main() {
	cout << "main" << "threadid = " << std::this_thread::get_id() << endl;
	//std::future<int> result = std::async(std::launch::deferred, mythread);
	std::future<int> result = std::async(mythread);
	cout << "continue........" << endl;
	//cout << result1.get() << endl; //卡在这里等待mythread()执行完毕，拿到结果
	std::future_status status = result.wait_for(std::chrono::seconds(6));
	if (status == std::future_status::timeout) {
		//超时：表示线程还没有执行完
		cout << "超时了，线程还没有执行完" << endl;
	}
	else if (status == std::future_status::ready) {
		//表示线程成功放回
		cout << "线程执行成功，返回" << endl;
		cout << result.get() << endl;
	}
	else if (status == std::future_status::deferred) {
		//如果设置 std::future<int> result = std::async(std::launch::deferred, mythread);，则本条件成立
		cout << "线程延迟执行" << endl;
		cout << result.get() << endl;
	}

	cout << "good luck" << endl;
	return 0;
}

二、std::shared_future：也是个类模板
  std::future的 get() 成员函数是转移数据
  std::shared_future 的 get()成员函数是复制数据

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

int mythread() {
	cout << "mythread() start" << "threadid = " << std::this_thread::get_id() << endl;
	std::chrono::milliseconds dura(5000);
	std::this_thread::sleep_for(dura);
	cout << "mythread() end" << "threadid = " << std::this_thread::get_id() << endl;
	return 5;
}

int main() {
	cout << "main" << "threadid = " << std::this_thread::get_id() << endl;
	std::packaged_task<int()> mypt(mythread);
	std::thread t1(std::ref(mypt));
	std::future<int> result = mypt.get_future();

	bool ifcanget = result.valid(); //判断future 中的值是不是一个有效值
	std::shared_future<int> result_s(result.share()); //执行完毕后result_s里有值，而result里空了
													  //std::shared_future<int> result_s(std::move(result));
													  //通过get_future返回值直接构造一个shared_future对象
													  //std::shared_future<int> result_s(mypt.get_future());
	t1.join();

	auto myresult1 = result_s.get();
	auto myresult2 = result_s.get();

	cout << "good luck" << endl;
	return 0;
}

三、std::atomic原子操作
3.1 原子操作概念引出范例：
  互斥量：多线程编程中 用于保护共享数据：先锁住， 操作共享数据， 解锁。
  有两个线程，对一个变量进行操作，一个线程读这个变量的值，一个线程往这个变量中写值。
  即使是一个简单变量的读取和写入操作，如果不加锁，也有可能会导致读写值混乱（一条C语句会被拆成3、4条汇编语句来执行，所以仍然有可能混乱）

#include <iostream>
#include <thread>
using namespace std;
int g_count = 0;
 
void mythread1() {
	for (int i = 0; i < 1000000; i++) {
		g_count++;
	}
}
 
int main() {
	std::thread t1(mythread1);
	std::thread t2(mythread1);
	t1.join();
	t2.join();
	cout << "正常情况下结果应该是200 0000次，实际是" << g_count << endl;
}

这个结果是不确定的
可以使用互斥量解决这个问题，但是效率低，互斥量针对代码段

#include <iostream>
#include <thread>
#include <mutex>
std::mutex mymutex;
using namespace std;
int g_count = 0;

void mythread1() {
	for (int i = 0; i < 1000000; i++) {
		std::unique_lock<std::mutex> u1(mymutex);
		g_count++;//这里得加锁，不然结果有问题，加锁保证++操作不会被打断
	}
}

int main() {
	std::thread t1(mythread1);
	std::thread t2(mythread1);
	t1.join();
	t2.join();
	cout << "正常情况下结果应该是200 0000次，实际是" << g_count << endl;
}

使用原子操作解决问题，原子操作针对变量
std::atomic来代表原子操作，是个类模板。其实std::atomic是用来封装某个类型的值的
需要添加#include <atomic>头文件

#include <iostream>
#include <thread>
#include <atomic>
using namespace std;
std::atomic<int> g_count = 0; //封装了一个类型为int的 对象（值）

void mythread1() {
	for (int i = 0; i < 1000000; i++) {
		g_count++;//++的操作是原子操作，不会被打断
	}
}
 
int main() {
	std::thread t1(mythread1);
	std::thread t2(mythread1);
	t1.join();
	t2.join();
	cout << "正常情况下结果应该是200 0000次，实际是" << g_count << endl;
}

atomic演示bool型变量

#include <iostream>
#include <thread>
#include <atomic>
using namespace std;
std::atomic<bool> g_ifEnd = false; //封装了一个类型为bool的 对象（值）

void mythread() {
	std::chrono::milliseconds dura(1000);
	while (g_ifEnd == false) {
		cout << "thread id = " << std::this_thread::get_id() << "运行中" << endl;
		std::this_thread::sleep_for(dura);
	}
	cout << "thread id = " << std::this_thread::get_id() << "运行结束" << endl;
}

int main() {
	std::thread t1(mythread);
	std::thread t2(mythread);
	std::chrono::milliseconds dura(5000);
	std::this_thread::sleep_for(dura);
	g_ifEnd = true;
	cout << "程序执行完毕" << endl;
	t1.join();
	t2.join();
}

总结：
  1、原子操作一般用于计数或者统计（如累计发送多少个数据包，累计接收到了多少个数据包），多个线程一起统计，这种情况如果不使用原子操作会导致统计发生混乱。
  2、写商业代码时，如果不确定结果的影响，最好自己先写一小段代码调试。或者不要使用。

第十一节 std::atomic续谈、std::async深入谈

一、std::atomic续谈

#include <iostream>
#include <thread>
#include <atomic>
using namespace std;
std::atomic<int> g_count = 0; //封装了一个类型为int的 对象（值）

void mythread1() {
	for (int i = 0; i < 1000000; i++) {
		//虽然g_count使用了原子操作模板，但是这种写法既读又写，
		//会导致计数错误
		//g_count = g_count + 1; 不支持
		g_count += 1;
	}
}

int main() {
	std::thread t1(mythread1);
	std::thread t2(mythread1);
	t1.join();
	t2.join();
	cout << "正常情况下结果应该是200 0000次，实际是" << g_count << endl;
	//打印出来的实际结果不是2000000，因为原子操作不是所有的操作符都支持
	//一定支持的操作符：++，–，+=，-=，&=，|=，^=
}

原子操作不是所有的操作符都支持,一定支持的操作符：++，–，+=，-=，&=，|=，^=

二、std::async深入理解
2.1 std::async参数详述，async 用来创建一个异步任务
  延迟调用参数 std::launch::deferred【延迟调用】，std::launch::async【强制创建一个线程】
  std::async()我们一般不叫创建线程（他能够创建线程），我们一般叫它创建一个异步任务。
  std::async和std::thread最明显的不同，就是 async 有时候并不创建新线程。
①如果用std::launch::deferred 来调用async？
  延迟到调用 get() 或者 wait() 时执行，如果不调用就不会执行
②如果用std::launch::async来调用async？
  强制这个异步任务在新线程上执行，这意味着，系统必须要创建出新线程来运行入口函数。
③如果同时用 std::launch::async | std::launch::deferred
  这里这个或者关系意味着async的行为可能是 std::launch::async 创建新线程立即执行， 也可能是 std::launch::deferred 没有创建新线程并且延迟到调用get()执行，由系统根据实际情况来决定采取哪种方案
④不带额外参数 std::async(mythread)，只给async 一个入口函数名
  此时的系统给的默认值是 std::launch::async | std::launch::deferred。 和 ③ 一样，系统自行决定异步还是同步运行。

2.2 std::async和std::thread()区别：
  std::thread()如果系统资源紧张可能出现创建线程失败的情况，如果创建线程失败那么程序就可能崩溃，而且不容易拿到函数返回值（不是拿不到）
  std::async()创建异步任务。可能创建线程也可能不创建线程，并且容易拿到线程入口函数的返回值；
 由于系统资源限制：
  ①如果用std::thread创建的线程太多，则可能创建失败，系统报告异常，崩溃。
  ②如果用std::async，一般就不会报异常，因为如果系统资源紧张，无法创建新线程的时候，async不加额外参数的调用方式就不会创建新线程。而是在后续调用get()请求结果时执行在这个调用get()的线程上。
如果你强制async一定要创建新线程就要使用 std::launch::async 标记。承受的代价是，系统资源紧张时可能崩溃。
  ③根据经验，一个程序中线程数量 不宜超过100~200 。
2.3 async不确定性问题的解决
  不加额外参数的async调用时让系统自行决定，是否创建新线程。
std::future result = std::async(mythread);
  问题焦点在于这个写法，任务到底有没有被推迟执行。通过wait_for返回状态来判断：

std::future_status status = result.wait_for(std::chrono::seconds(6));
//std::future_status status = result.wait_for(6s);
	if (status == std::future_status::timeout) {
		//超时：表示线程还没有执行完
		cout << "超时了，线程还没有执行完" << endl;
	}
	else if (status == std::future_status::ready) {
		//表示线程成功放回
		cout << "线程执行成功，返回" << endl;
		cout << result.get() << endl;
	}
	else if (status == std::future_status::deferred) {
		cout << "线程延迟执行" << endl;
		cout << result.get() << endl;
	}

第十二节 windows临界区、其他各种mutex互斥量windows临界区

一、Windows临界区
 Windows临界区，同一个线程是可以重复进入的，但是进入的次数与离开的次数必须相等。
 C++互斥量则不允许同一个线程重复加锁。
windows临界区是在windows编程中的内容，效果几乎可以等同于c++11的mutex
 包含#include <windows.h>
 windows中的临界区同mutex一样，可以保护一个代码段。但windows的临界区可以进入多次，离开多次，但是进入的次数与离开的次数必须相等，不会引起程序报异常出错。
二、自动析构技术
 C++：lock_guard防止忘了释放信号量，自动释放
 windows：可以写个类自动释放临界区：

#include <iostream>
#include <thread>
#include <list>
#include <mutex>
#include <Windows.h>

#define __WINDOWSJQ_

using namespace std;
//自己写一个类似C++中lock_guard能自动释放锁的类
//自动析构技术
class CWinLock {
public:
	CWinLock(CRITICAL_SECTION *pCritmp)
	{
		my_winsec = pCritmp;
		EnterCriticalSection(my_winsec);
	}
	~CWinLock()
	{
		LeaveCriticalSection(my_winsec);
	}
private:
	CRITICAL_SECTION *my_winsec;
};


class A
{
public:
	// 把收到的消息传入队列
	void inMsgRecvQueue()
	{
		for (size_t i = 0; i < 100000; ++i)
		{
			cout << "收到消息，并放入队列 " << i << endl;

#ifdef  __WINDOWSJQ_
		  //EnterCriticalSection(&my_winsec);	//	进入临界区
		  //EnterCriticalSection(&my_winsec);	//	可以再次进入临界区,程序不会出错
			//改成自己写的一个类,这样可以不用再解锁
			CWinLock wlock(&my_winsec);
			msgRecvQueue.push_back(i);
		  //LeaveCriticalSection(&my_winsec);	//	离开临界区
		  //LeaveCriticalSection(&my_winsec);	//	如果进入两次，必须离开两次不会报错
#else
			my_mutex.lock();
			msgRecvQueue.push_back(i);
			my_mutex.unlock();
#endif //  __WINDOWSJQ_
		}

		cout << "消息入队结束" << endl;
	}

	// 从队列中取出消息
	void outMsgRecvQueue()
	{
		for (size_t i = 0; i < 1000000; ++i)
		{
#ifdef  __WINDOWSJQ_
			EnterCriticalSection(&my_winsec);	//	进入临界区
			if (!msgRecvQueue.empty())
			{
				// 队列不为空
				int num = msgRecvQueue.front();
				cout << "从消息队列中取出 " << num << endl;
				msgRecvQueue.pop_front();
			}
			else
			{
				// 消息队列为空
				cout << "消息队列为空 " << endl;
			}
			LeaveCriticalSection(&my_winsec);	//	离开临界区
#else
			my_mutex.lock();
			if (!msgRecvQueue.empty())
			{
				// 队列不为空
				int num = msgRecvQueue.front();
				cout << "从消息队列中取出 " << num << endl;
				msgRecvQueue.pop_front();
				my_mutex.unlock();
			}
			else
			{
				// 消息队列为空
				cout << "消息队列为空 " << endl;
				my_mutex.unlock();
			}
#endif //  __WINDOWSJQ_
		}

		cout << "消息出队结束" << endl;
	}

	A()
	{
#ifdef __WINDOWSJQ_
		InitializeCriticalSection(&my_winsec);	//	用临界区之前要初始化
#endif // __WINDOWSJQ_

	}

private:
	list<int> msgRecvQueue;
	mutex my_mutex;

#ifdef __WINDOWSJQ_
	CRITICAL_SECTION my_winsec;	//	windows中的临界区，非常类似C++11中的mutex
#endif // __WINDOWSJQ_

};

int main()
{
	A myobj;
	thread	myInMsgObj(&A::inMsgRecvQueue, &myobj);
	thread	myOutMsgObj(&A::outMsgRecvQueue, &myobj);
	myInMsgObj.join();
	myOutMsgObj.join();

	getchar();
	return 0;
}

三、递归独占互斥量 std::recursive_mutex
 std::mutex 独占式互斥量
 std::recursive_mutex：允许在同一个线程中同一个互斥量多次被 lock() ，（但是递归加锁的次数是有限制的，太多可能会报异常），效率要比mutex低。使用方法和mutex基本一致，区别就是可以多次lock，但是能调用一次 lock()就不要调用多次。

四、带超时的互斥量 std::timed_mutex 和 std::recursive_timed_mutex
 1）std::timed_mutex：是待超时的独占互斥量
 函数1：try_lock_for()：
  等待一段时间，如果拿到了锁，或者超时了未拿到锁，就继续执行（有选择执行）如下

std::time_mutex my_mutex;
std::chrono::milliseconds timeout(100);
if (my_mutex.try_lock_for(timeout)){
    //......拿到锁返回ture
}
else{
    std::chrono::milliseconds sleeptime(100);
    std::this_thread::sleep_for(sleeptime);
}

 函数2：try_lock_until()：
  参数是一个未来的时间点，在这个未来的时间没到的时间内，如果拿到了锁头，流程就走下来，如果时间到了没拿到锁，流程也可以走下来。

std::time_mutex my_mutex;
std::chrono::milliseconds timeout(100);
if (my_mutex.try_lock_until(chrono::steady_clock::now() + timeout)){
    //......拿到锁返回ture
}
else{
    std::chrono::milliseconds sleeptime(100);
    std::this_thread::sleep_for(sleeptime);
}

两者的区别就是一个参数是时间段，一个参数是时间点
 2）std::recursive_timed_mutex：是待超时的递归独占互斥量

第十三章 补充知识、线程池浅谈、数量谈、总结

一、补充知识点
1.1 虚假唤醒：
  notify_one或者notify_all唤醒wait()后，实际有些线程可能不满足唤醒的条件，就会造成虚假唤醒，可以在wait中再次进行判断解决虚假唤醒。
  解决：wait中要有第二个参数（lambda），并且这个lambda中要正确判断所处理的公共数据是否存在。
1.2 atomic

std::atomic<int> atm = 0;
cout << atm << endl;
//这里只有读取atm是原子操作，但是整个这一行代码 cout << atm << endl; 并不是原子操作，导致最终显示在屏幕上的值是一个“曾经值”，atm可能早就改变了


std::atomic<int> atm = 0;
auto atm2 = atm; //不可以，会报错“尝试引用已删除元素”，拷构造函数以及赋值构造函数都不能用，原子操作实现这些函数很复杂


atomic<int> atm2(atm.load());//load()：以原子方式读atomic对象的值。

atm2.store(12);//store()：以原子方式改变atomic对象的值。

原子操作实质上是：不允许在进行原子对象操作时进行CPU的上下文切换。
二、浅谈线程池：
场景设想：服务器程序， 每来一个客户端，就创建一个新线程为这个客户提供服务。
问题：
 1、2万个玩家，不可能给每个玩家创建一个新线程，此程序写法在这种场景下不通。
 2、程序稳定性问题：编写代码中，“时不时地突然”创建一个线程，这种写法，一般情况下不会出错，但是不稳定的；
线程池：把一堆线程弄到一起，统一管理。这种统一管理调度，循环利用的方式，就叫做线程池。
实现方式：程序启动时，一次性创建好一定数量的线程。这种方式让人更放心，觉得程序代码更稳定。
三、线程创建数量谈：
1、线程创建的数量极限的问题
  一般来讲，2000个线程基本就是极限；再创建就会崩溃。
2、线程创建数量建议
  a、采用某些计数开发程序提供的建议，遵照建议和指示来确保程序高效执行。
  b、创建多线程完成业务；考虑可能被阻塞的线程数量，创建多余最大被阻塞线程数量的线程，如100个线程被阻塞再充值业务，开110个线程就是很合适的
  c、线程创建数量尽量不要超过500个，尽量控制在200个之内；