线程三----------异步操作

        异步操作是一种执行任务而无需等待其完成的方式。异步操作可以提高程序的并发性和响应性，适用于需要长时间执行的任务或需要与外部资源进行交互的情况。C++中提供了异步操作相关的类，主要有：std::future,std::promise和std::package_task。

          其中std::future作为异步结果的传输通道，可以很方便地获取线程函数的返回值；std::promise用来包装一个值，将数据和future绑定起来，方便线程赋值；std::package_task用来包装一个可调用对象，将函数和future绑定起来，以便异步调用。

1.2.1获取线程函数返回值的类：std::future

        C++11中增加的线程，使得我们可以非常方便的创建和使用线程，但是当我们希望获取线程函数的返回结果，就不能直接通过thread.join()得到结果，这时就必须定义一个变量，通过在线程函数中去给变量赋值，然后执行join()，最后得到结果。当我们有了future后，就可以避免这种繁琐的过程，因为一个异步操作的结果不能马上获取，只能在未来的某个时刻获取，所以被称为future。通过future提供的future_status的三个状态来判断异步操作的状态：

        1.Deferred:异步操作还未开始。

        2.Ready,异步操作已经完成。

        3.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)

获取future结果有三种方式：get,wait,wait_for，其中get等待异步操作结束并返回结果，wait只是等待异步操作完成，无返回值，wait_for是超时等待返回结果。

1.2.2 协助线程赋值的类std::promise：

        std::promise将数据和future绑定起来，为获取线程函数中的某个值提供便利，在线程函数中为外面传进来的promise赋值，在线程函数执行完成之后可以通过promise的future获取该值了。需要注意的是：取值是间接的通过promise内部提供的future来获取的。

std::promise的使用方法如下：

std::promise<int> pr;
auto lambda = [](std::promise<int>&p){
    p.set_value_at_thread_exit(9);
}
//std::ref()引用包装器,thread的方法传递引用的时候，必须用ref来进行引用传递，否则就是浅拷贝。
std::thread t(lambda,std::ref(pr));
std::future<int> f = pr.get_future();
auto r = f.get();

1.2.3可调用对象的包装类std::package_task:

        std::packaged_task包装了一个可调用对象的包装类(如 function，lambda expression,bind expression和another function object),将函数和future绑定起来，以便异步调用，它和std::promise在某种程度上有点像，promise保存了一个共享状态的值，而package_task保持的是一个函数。

使用方法如下：

std::packaged_task<int()> task(()[]{return 7});
std::thread t1(std::ref(task));
std::future<int> f1 = task.get_future();
auto r1 = f1.get();

        从上面的例子来看，package_task相当于是内置了promise,所以其使用方法就不需要额外的传递promise进去，而直接使用get_future来获取future即可。

1.3std::promise,std::packaged_task和std::future三者之间的关系：

       之前我们也提到了promise和package_task其内部包含了，所以promise和package_task是比future更高一层的，future和线程是同一层的，属于低层次的对象。不过package_task包装的是一个异步的操作，而promise包装的是一个值。如果需要获取线程中的某个值，就是用promise，如果要获得一个异步操作的返回值就是要package_task。

1.4线程异步操作函数async：

        std::async比std::promise，std::package_task,std::thread更高一层，它可以用来直接创建异步的task,异步任务返回的结果也保存在future中，当需要获取异步任务的结果时，只需要调用future.get()方法即可，如果不关注异步任务的结果，只是简单的等待任务完成的话，则调用future.wait()方法。async的原型 如下：

async(std::launch::async | std::launch::deferred,f,args...)

        第一个参数是线程的创建策略，有两种策略，默认的策略是立即创建线程。

std::launch::async :在调用async时就开始创建线程
std::launch::deferred:延迟加载方式创建线程。调用async时不创建线程，直到调用了future的get或者wait时才创建线程。

        第二个参数是线程函数，第三个参数是线程函数的参数。

用法如下：

void thread_async_test()
{
	std::future<int> f1 = std::async(std::launch::async, []() {
		return 8;
		});
	cout << f1.get() << endl;

	std::future<void> f2 = std::async(std::launch::async, []() {
		cout << 8 << endl;
		});
	f2.wait();

	std::future<int> future = std::async(std::launch::async, []() {
		std::this_thread::sleep_for(std::chrono::seconds(3));//this_thread sleep3s
		return 9;
		});
	cout << "wait" <<endl;
	std::future_status f_status;
	do {
		f_status = future.wait_for(std::chrono::seconds(1));//等待1s
		if (f_status == std::future_status::deferred)
		{
			cout << "deferred\n";
		}
		else if (f_status == std::future_status::timeout)
		{
			cout << "timeout\n";
		}
		else if (f_status == std::future_status::ready)
		{
			cout << "ready\n";
		}
	} while (f_status != std::future_status::ready);
	cout << "result is" << future.get() <<endl;
}

        std::sync是更高层次的异步操作，使得我们不用关注线程创建内部的细节，就能方便获取异步执行状态和结果，还可以指定线程创建策略，所以我们要在异步操作的时候，使用std::async来替代线程的创建。