C++11异步操作-std::future

C++11异步操作-std::future

介绍

std::future是C++11标准库中的⼀个模板类，它表⽰⼀个异步操作的结果。当我们在多线程编程中使⽤异步任务时，std::future可以帮助我们在需要的时候获取任务的执⾏结果。std::future的⼀个重要特性是能够阻塞当前线程，直到异步操作完成，从⽽确保我们在获取结果时不会遇到未完成的操作。

应⽤场景

• 异步任务：当我们需要在后台执⾏⼀些耗时操作时，如⽹络请求或计算密集型任务等，std::future可以⽤来表⽰这些异步任务的结果。通过将任务与主线程分离，我们可以实现任务的并⾏处理，从⽽提⾼程序的执⾏效率 。

• 并发控制：在多线程编程中，我们可能需要等待某些任务完成后才能继续执⾏其他操作。通过使⽤std::future，我们可以实现线程之间的同步，确保任务完成后再获取结果并继续执⾏后续操作 。

• 结果获取：std::future提供了⼀种安全的⽅式来获取异步任务的结果。我们可以使⽤std::future::get()函数来获取任务的结果，此函数会阻塞当前线程，直到异步操作完成。这样，在调⽤get()函数时，我们可以确保已经获取到了所需的结果 。

⽤法⽰例

使⽤std::async关联异步任务

std::async是⼀种将任务与std::future关联的简单⽅法。它创建并运⾏⼀个异步任务，并返回⼀个与该任务结果关联的std::future对象。默认情况下，std::async是否启动⼀个新线程，或者在等待future时，任务是否同步运⾏都取决于你给的参数。这个参数为**(enum)std::launch**类型：

• std::launch::deferred:表明该函数会被延迟调⽤，直到在future上调⽤get()或者wait()才会开始执⾏任务

• std::launch::async:表明函数会在⾃⼰创建的线程上运⾏

• std::launch::deferred|std::launch::async:内部通过系统等条件⾃动选择策略

示例：

#include <iostream>
#include <future>
#include <chrono>

int async_task()
{
	std::this_thread::sleep_for(std::chrono::seconds(3));
	return 2;
}

int main()
{
	// 关联异步任务aysnc_task 和 futrue
	std::future<int> res_future = std::async(std::launch::async, async_task);

	// 此处可执⾏其他操作, ⽆需等待
	std::cout << "hello" << std::endl;

	// 获取异步任务结果
	int res = res_future.get();
	std::cout << "Result:" << res << "\n";
	return 0;
}

结果：

xdt@hcss-ecs-e454:~/test_future$ g++ async.cc -o async -lpthread
xdt@hcss-ecs-e454:~/test_future$ ls
async  async.cc
xdt@hcss-ecs-e454:~/test_future$ ./async 
hello
Result:2		

运行过程中阻塞了3秒钟才获取到了结果。

使⽤std::packaged_task和std::future配合

std::packaged_task就是将任务和std::feature绑定在⼀起的模板，是⼀种对任务的封装。我们可以通过std::packaged_task对象获取任务相关联的std::future对象，通过调⽤get_future()⽅法获得。std::packaged_task的模板参数是函数签名。

可以把std::future和std::async看成是分开的，⽽std::packaged_task则是⼀个整体。

示例：

#include <iostream>
#include <future>
#include <chrono>

int add(int n1,int n2)
{
	return n1 + n2;
}

int main()
{
	// 封装任务
	std::packaged_task<int(int,int)> task(add);

	// 此处可执⾏其他操作, ⽆需等待
	std::cout << "hello" << std::endl;

	std::future<int> res_future = task.get_future();

	// 这⾥必须要让任务执⾏, 否则在get()获取future的值时会⼀直阻塞
	task(1,2);

	//避免主线程比任务先结束
	std::this_thread::sleep_for(std::chrono::seconds(2));

	// 获取异步任务结果
	int result = res_future.get();
	std::cout << "Result:" << result << "\n";

	return 0;
}

结果：

xdt@hcss-ecs-e454:~/test_future$ g++ packaged_task.cc -o packaged_task -lpthread
xdt@hcss-ecs-e454:~/test_future$ ./packaged_task 
hello
Result:3

以上示例虽然也能实现异步效果，但是会出现一个问题就是主线程可能会比任务先行结束，导致task的生命周期提前结束了导致 task(1, 2) 调用时，任务对象已经失效。

异步执⾏std::packaged_task任务，使用 std::thread + std::packaged_task

#include <iostream>
#include <future>
#include <chrono>
#include <memory>
int add(int n1,int n2)
{
	std::this_thread::sleep_for(std::chrono::seconds(2));
	return n1 + n2;
}

int main()
{
	auto task = std::make_shared<std::packaged_task<int(int,int)>>(add);
	std::future<int> res_future = task->get_future();
	std::thread thr([task](){
		(*task)(1,2);
	});
	thr.detach();

	// 此处可执⾏其他操作, ⽆需等待
	std::cout << "hello" << std::endl;

	// 获取异步任务结果
	int result = res_future.get();
	std::cout << "Result:" << result << "\n";
	return 0;
}

这里需要注意一点

//task虽然重载了()运算符，但task并不是⼀个函数，
//std::async(std::launch::async, task, 1, 2); //--错误⽤法
//所以导致它作为线程的⼊⼝函数时，语法上看没有问题，但是实际编译的时候会报错
//std::thread(task, 1, 2); //---错误⽤法
//⽽packaged_task禁⽌了拷⻉构造，
//且因为每个packaged_task所封装的函数签名都有可能不同，因此也⽆法当作参数⼀样传递
//传引⽤不可取，毕竟任务在多线程下执⾏存在局部变量声明周期的问题，因此不能传引⽤
//因此想要将⼀个packaged_task进⾏异步调⽤，
//简单⽅法就只能是new packaged_task，封装函数传地址进⾏解引⽤调⽤了
//或者可以通过std::move来进行传递
//⽽类型不同的问题，在使⽤的时候可以使⽤类型推导来解决  

使⽤std::promise和std::future配合

std::promise提供了⼀种设置值的⽅式，它可以在设置之后通过相关联的std::future对象进⾏读取。换种说法就是之前说过std::future可以读取⼀个异步函数的返回值了，但是要等待就绪，⽽std::promise就提供⼀种⽅式⼿动让std::future就绪。

示例：

#include <iostream>
#include <future>
#include <chrono>

void task(std::promise<int> result_promise)
{
	int result = 2;
	std::cout << "task result:" << result << std::endl;
	std::this_thread::sleep_for(std::chrono::seconds(3));
	result_promise.set_value(result);	//手动设置
}

int main()
{
	// 创建promise
	std::promise<int> res_promise;
	std::future<int> res_future = res_promise.get_future();

	// 创建⼀个新线程， 执⾏⻓时间运⾏的任务
	std::thread tesk_thr(task,std::move(res_promise));

	// 此处可执⾏其他操作, ⽆需等待
	std::cout << "hello" << std::endl;

	// 获取异步任务结果
	int result = res_future.get();
	std::cout << "Result:" << result << "\n";

	tesk_thr.join();
	return 0;
}

结果：

xdt@hcss-ecs-e454:~/test_future$ g++ promise.cc -o promise -lpthread
xdt@hcss-ecs-e454:~/test_future$ ./promise 
hello
task result:2
Result:2