C++并发与多线程(九)future_status、shared_future、atomic

future_status

std::future_status status = result.wait_for(std::chrono::seconds(1)); //等待1s

卡住当前流程，等待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 //线程延迟执行

	//枚举类型
	future_status status = result.wait_for(chrono::seconds(1)); //等待1s
	if (status == future_status::timeout) {
		cout << "超时，线程还没结束" << endl;
	}
	else if(status == future_status::ready){
		cout << "线程成功执行完毕" << endl;
		cout << result.get() << endl;
	}
	else if (status == future_status::deferred) {
		cout << "线程延迟执行" << endl;
		cout << result.get() << endl;
	}

std::shared_future

future::get()方法：

get()只能使用一次，第二次调用就会报错

cout << result.get() << endl; //正确
cout << result.get() << endl; //错误

因为get()函数的设计是一个移动语义，相当于将result中的值移动（而不是复制），再次get就报告了异常（因为原来的值已经不见了只有一份）。

如果在多个线程中，我们都希望使用result.get()的值，就需要使用shared_future：

std::shared_future 的 get()成员函数是复制数据，而不是移动数据；

使用方法：

future<int> result = mypt.get_future();

shared_future<int> result_s = (result.share()); //result的值赋给result_s，此时result里面已经为空了

auto myresult1 = result_s.get(); //获取一次结果
auto myresult2 = result_s.get(); //获取多次结果

bool ifempty = result.valid(); //ifempty = true, valid方法用于判断result里面是否为空

std::atomic

原子操作的理解：

互斥量 ：多线程编程中用于保护共享数据，先上锁， 操作共享数据， 再解锁。

假设有两个线程，对一个变量进行操作，一个线程读这个变量的值，一个线程往这个变量中写值。即使这只是一个简单变量的读取和写入操作，如果不加锁，也有可能会导致读写值混乱（一条C语句会被拆成3、4条汇编语句来执行，所以仍然有可能混乱）

int g_mycount = 0;
 
void myThread() {
	for (int i = 0; i < 1000000; i++) {
		g_mycount++;
	}
}
 
int main() {
	std::thread mythread1(myThread);
	std::thread mythread2(myThread);
	mythread1.join();
	mythread2.join();
	cout << "正常情况下结果应该是200 0000次，实际是" << g_mycount << endl;
}

想要避免这种冲突，只能引入互斥量，在myThread加锁：mutex.lock()，这样最终执行的次数才会是200 0000次；

其实除了互斥量，我们还可以使用原子操作的方式，来避免这种冲突；简单来说，原子操作 = 不需要用到互斥量加锁（无锁）技术的多线程并发编程方式。

1. 原子操作：在多线程中不会被打断的程序执行片段。这种操作一般都是指“不可分割的操作”；也就是说这种操作状态要么是完成的，要么是没完成的，不可能出现半完成状态。
2. 互斥量的加锁一般是针对一个代码段，而原子操作针对的一般都是一个变量。
3. 从效率上来说，原子操作要比互斥量的方式效率要高。

std::atomic来代表原子操作，它是一个类模板，是用来封装某个类型的值；

//添加头文件
#include <atomic>
atomic<int> g_mycount = 0; //封装一个类型为int的atomic对象
 
void myThread() {
	for (int i = 0; i < 1000000; i++) {
		g_mycount++;
	}
}
 
int main() {
	std::thread mythread1(myThread);
	std::thread mythread2(myThread);
	mythread1.join();
	mythread2.join();
	cout << "正常情况下结果应该是200 0000次，实际是" << g_mycount << endl;
}

1. 添加头文件#include < atomic >
2. int --> atomic< int >，封装一个int类型的atmoic对象，以后再使用g_mycount的时候，可以认为他是一个原子的（也就是说，对他的操作不会被打断，不会出现，汇编语言执行到一半，就去执行别的，导致他的值是一个中间值；他的值只能是执行前，或者执行后的值，不可能是中间值）；其余代码不需要变化，不需要使用互斥量，把他按照int类型操作即可。
3. 一般atomic原子操作，针对**++，–，+=，-=，&=，|=，^=**是支持的，其他操作不一定支持。

总之
4. 原子操作一般用于计数或者统计（如累计发送多少个数据包，累计接收到了多少个数据包），多个线程一起统计，这种情况如果不使用原子操作会导致统计发生混乱。

5. 写商业代码时，如果不确定结果的影响，最好自己先写一小段代码调试。或者不要使用。