std::future的使用

//传递类参数，智能指针作为线程参数

#include
#include
#include
#include 

#include 
using namespace std;

void f(int n)
{
	cout << n << endl;
}

std::string helloFunction(const std::string& s)
{
	std::chrono::milliseconds dura(2000);
	std::this_thread::sleep_for(dura);

	return "Hello C++11 from " + s + ".";
}

class HelloFunctionObject
{
public:
	std::string operator()(const std::string& s) const
	{
		std::chrono::milliseconds dura(2000);
		std::this_thread::sleep_for(dura);

		return "Hello C++11 from " + s + ".";
	}
};

int main()
{
	//用来创建异步任务
	//std::async

	//int n = 6;
	//std::thread t(f, n + 1);
	//t.join();


	// 带函数的future
	auto futureFunction = std::async(helloFunction, "helloFunction");

	// 带函数对象的future
	HelloFunctionObject helloFunctionObject;
	auto futureFunctionObject = std::async(helloFunctionObject, "function object");

	// 带匿名函数的future
	auto futureLambda = std::async(
		[](const std::string& s)
	{
		return "Hello C++11 from " + s + ".";
	},
		"lambda function"
		);


	//只有调用get()时，才等待直到结果返回-------卡住
	cout << futureFunction.get().c_str() << endl;
	cout << futureFunctionObject.get().c_str() << endl;
	cout << futureLambda.get().c_str() << std::endl;



	//C++运行时决定, 计算是发生在同一个线程还是一个新的线程。
	//	使用std::launch::async参数的话，std::async 将在一个新线程中运行它的工作包。

	//	相反，使用参数 std::launch::deferred, std::async将在同一个线程中运行它的工作包。 这种情况下属于惰性求值。

	//	这意味着，急速求值是立即执行的，但是惰性求值的策略std::launch::deferred是随着future调用get()后才开始执行


	std::cout << std::endl;

	auto begin = std::chrono::system_clock::now();

	auto asyncLazy = std::async(
		std::launch::deferred,//将在同一个线程中运行它的工作包,惰性求值
		[] 
		{ 
			return  std::chrono::system_clock::now(); 
		}
	);

	auto asyncEager = std::async(
		std::launch::async, //将在一个新线程中运行它的工作包
		[] 
		{
			return  std::chrono::system_clock::now(); 
		}
	);

	std::this_thread::sleep_for(std::chrono::seconds(1));

	auto lazyStart = asyncLazy.get() - begin;//1.00053   asyncLazy.get()调用，结果在一个短暂的打盹后才能获得,调用get()时才真正去执行
	auto eagerStart = asyncEager.get() - begin;//0.0179519  立刻执行函数里代码

	auto lazyDuration = std::chrono::duration(lazyStart).count();
	auto eagerDuration = std::chrono::duration(eagerStart).count();

	std::cout << "asyncLazy evaluated after : " << lazyDuration << " seconds." << std::endl;	//1.00053
	std::cout << "asyncEager evaluated after: " << eagerDuration << " seconds." << std::endl;	//0.0179519

	std::cout << std::endl;


	//我希望获取线程函数的返回结果的时候，我就不能直接通过thread.join()得到结果
	//std::async会自动创建一个线程去调用线程函数，它返回一个std::future，
	//这个future中存储了线程函数返回的结果，当我们需要线程函数的结果时，直接从future中获取

	//它首先解耦了线程的创建和执行，使得我们可以在需要的时候获取异步操作的结果；
	//其次它还提供了线程的创建策略（比如可以通过延迟加载的方式去创建线程）

	//std::future是一个非常有用也很有意思的东西，简单说std::future提供了一种访问异步操作结果的机制。
	//从字面意思来理解，它表示未来，我觉得这个名字非常贴切，因为一个异步操作我们是不可能马上就获取操作结果的，只能在未来某个时候获取，
	//但是我们可以以同步等待的方式来获取结果，可以通过查询future的状态（future_status）来获取异步操作的结果

	//future_status有三种状态：
	//	deferred：异步操作还没开始
	//	ready：异步操作已经完成
	//	timeout：异步操作超时



	//查询future的状态
	//std::future_status status;
	//do {

	//	status = future.wait_for(std::chrono::seconds(1));
	//	if (status == std::future_status::deferred) 
	//	{
	//		std::cout << "deferred\n";
	//	}
	//	else if (status == std::future_status::timeout) 
	//	{
	//		std::cout << "timeout\n";
	//	}
	//	else if (status == std::future_status::ready) 
	//	{
	//		std::cout << "ready!\n";
	//	}

	//} while (status != std::future_status::ready);




	cout << "I love china !" << endl;

	getchar();

	return 0;
}