一：std::async std::future 创建后台任务，并返回值
希望线程返回一个结果
std::async 是一个函数模板，用来启动一个异步任务；之后返回一个std::future对象，是个类模板。
“启动一个异步任务”，自动创建一个线程并开始执行对应的线程入口函数，返回std::future对象，里面含有线程入口函数所返回的结果。使用get()函数获取。
参数：
1）std::launch::deferred 表示线程入口函数调用被延迟到std::future 的 wait()或者 get()函数调用时才执行
如果wait() or get() 没调用，程序没执行，根本就没创建。
std::launch::deferred：延迟调用，并且没有创建新线程，只是在主线程中调用的线程入口函数

2)std:;launch::async ,在调用async函数的时候就开始创建线程
//系统默认使用此模式

二、std::packaged_task 打包任务，把任务包装起来
是类模板，模板参数是各种可调用对象。

三、std::promise,类模板，在某个线程赋值，又在另一个线程将值取处
//总结：通过promise保存一个值，在将来某个时刻通过把future绑定到这个promise上来，得到这个绑定的值

std::async与std::future 函数举例

#include "stdafx.h"
#include<future>
#include<thread>
#include<iostream>
using namespace std;
#include<vector>
int mythread(int mypar)
{
	cout << "mypar = " << 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;
}

int main()
{
	cout << "main " << "threadid = " << std::this_thread::get_id() << endl;
	std::future<int> result = (mythread,15);  //创建一个线程开始执行，绑定关系，流程不卡在这
	cout << "contine...." << endl;
	int def = 0;
	cout << result.get() << endl;  //卡在这里等待mythread()执行完毕，拿到返回值  自能调用一次
	//result.wait();//等待线程返回，本身不返回结果
	cout << "结束" << endl;
	return 0;
}

main threadid = 8332
contine…
mypar = 15
mythread() start threadid = 1368
mythread() end threadid = 1368
5
结束
请按任意键继续. . .

std::async与std::future 类成员函数举例

// 线程7.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<future>
#include<thread>
#include<iostream>
using namespace std;
#include<vector>
class A
{
public:
	int mythread(int mypar)
	{
		cout << "mypar = " << 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;
	}
};
int main()
{
	//类成员函数举例
	A a;
	int mypar = 12;
	cout << "main " << "threadid = " << std::this_thread::get_id() << endl;
	std::future<int> result = std::async(std::launch::deferred , &A::mythread, &a, mypar); //第二个参数是对象引用，才能保证线程里用的是同一个对象 
	cout << "contine...." << endl;
	int def = 0;
	cout << result.get() << endl;  //卡在这里等待mythread()执行完毕，拿到返回值  自能调用一次
	cout << "结束" << endl;
	return 0;
}

参数std::launch::deferred 结果显示
main threadid = 10388
contine…
mypar = 12
mythread() start threadid = 10388
mythread() end threadid = 10388
5
结束
请按任意键继续. . .
参数std::launch::async 结果显示
main threadid = 3020
contine…
mypar = 12
mythread() start threadid = 11148
mythread() end threadid = 11148
5
结束
请按任意键继续. . .

packaged_task用法

#include "stdafx.h"
#include<future>
#include<thread>
#include<iostream>
using namespace std;
#include<vector>

int main()
{
	//packaged_task用法
	cout << "main " << "threadid = " << std::this_thread::get_id() << endl;
	std::packaged_task<int(int)>mypt([](int mypar) {
		cout << "mypar = " << 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;
	}); //我们把函数mythread通过packaged_task包装起来
	{
	std::thread t1(std::ref(mypt),12);
	t1.join();
	std::future<int> result = mypt.get_future();//std::future对象包含线程入口函数的返回结果，这里result 保存mythread的返回结果
	cout << result.get() << endl;
	}
	{//也可以这样
	//mypt(1314); // 相当于函数调用
	//std::future<int> result = mypt.get_future();
	//cout << result.get() << endl;
	}
	cout << "结束" << endl;
	return 0;
}

main threadid = 4924
mypar = 1314
mythread() start threadid = 4924
mythread() end threadid = 4924
5
结束
请按任意键继续. . .

packaged_task 容器移动

#include "stdafx.h"
#include<future>
#include<thread>
#include<iostream>
using namespace std;
#include<vector>
vector <std::packaged_task<int(int)>> mytask;
int main()
{
	//packaged_task用法
	cout << "main " << "threadid = " << std::this_thread::get_id() << endl;
	std::packaged_task<int(int)>mypt([](int mypar) {
		cout << "mypar = " << 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;
	}); //我们把函数mythread通过packaged_task包装起来

	mytask.push_back(std::move(mypt));//入容器，这里用移动语义，入进去之后mypt为空
	std::packaged_task<int(int)>mypt2;
	auto iter = mytask.begin();
	mypt2 = std::move(*iter);//移动语义
	mytask.erase(iter);//删除第一个元素，后续不可使用iter
    mypt2(1314); // 相当于函数调用
	std::future<int> result = mypt2.get_future();
	cout << result.get() << endl;
	cout << "结束" << endl;
	return 0;
}

// 线程7.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<future>
#include<thread>
#include<iostream>
using namespace std;
#include<vector>
void mythread3(std::promise<int> &tmpp,int calc) 
{
	std::chrono::milliseconds dura(5000);
	std::this_thread::sleep_for(dura);
	calc++;
	calc *= 10;

	int result = calc;
	tmpp.set_value(result);
	return;
}

void mythread4(std::future<int> &tmpf)
{
	auto result = tmpf.get();
	cout << "mythread4 result = " << result << endl;
	return;
}

int main()
{
	//std::promise,类模板
	std::promise<int>myprom;//声明一个std::promise对象myprom，保存值类型为int
	std::thread t1(mythread3,std::ref(myprom),12);
	t1.join();
    //获取结果
	std::future<int> fu1 = myprom.get_future();//promise 与 future 绑定，用于获取线程返回值
	/*auto result = fu1.get();
	cout << "result = " << result << endl;*/

	std::thread t2(mythread4,std::ref(fu1));    
	t2.join();//等待thread4线程执行完毕
	cout << "结束" << endl;
	return 0;
}