C++11-std::async

发表于 | 分类于 | | 阅读次数:

用C++11的std::async代替线程的创建

c++11中增加了线程，使得我们可以更方便的创建线程，它的基本用法如下：

1
2
3
void f(int n);
std::thread t(f, n+1);
t.join();

但是线程毕竟是属于比较低层次的东西，有时候用起来不便，比如：我要获取 线程函数的返回结果 的时候，我就不能直接通过thread.join()得到结果，这时就必须定义一个变量，在线程函数中去给这个变量赋值，然后join，最后得到结果，这个过程是比较繁琐的。

c++11还提供了异步接口std::async，通过这个异步接口可以很方便的获取 线程函数的执行结果。 std::async会自动创建一个线程去调用线程函数，它返回一个std::future，这个 future 中存储了线程函数的返回结果，当我们需要线程函数的结果时，直接从future中获取，非常方便。但是我想说的是，其实std::async给我们提供的便利不仅仅于此，它首先解耦了线程的创建和执行，使得我们可以在需要的时候获取异步操作的结果；其次，它还提供了线程的创建策略（比如可以通过延迟加载的方式去创建线程），使得我们可以以多种方式去创建线程。在介绍async具体用法以及为什么要用std::async代替线程的创建之前，我先说一下std::future、std::promise和std::packaged_task。

std::future

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

  • defered: 异步操作还没开始
  • ready: 异步操作已经完成
  • timeout: 异步操作超时
1
2
3
4
5
6
7
8
9
10
11
12
// 查询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是超时等待返回结果。

std::promise

std::promise为获取线程函数中的某个值提供便利，在线程函数中给外面传进来的promise赋值，当线程函数执行完成之后就可以通过promise获取该值了，值得注意的是取值是 间接的通过promise内部提供的future来获取的。它的基本用法：

1
2
3
4
5
std::promise<int> pr;
std::thread t([](std::promise<int>& p) { p.set_value_at_thread_exit(9); }, std::ref(pr));

std::future<int> f = pr.get_future();
auto r = f.get();

std::packaged_task

std::pakcaged_task它包装了一个可调用的目标（如function, lambda expression, bind expression, or another function object），以便异步调用，它和promise在某种程度上有点像，promise保存了一个共享状态的值，而packaged_task保存的是一个函数。它的基本用法：

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

std::promise、std::packaged_task和std::future的关系

至此，我们介绍了std::aync相关的几个对象std::future、std::promise和std::packaged_task，其中std::promise和std::packaged_task的结果最终都是通过其内部的future返回出来的，那这几种方式的区别与关系是什么呢？

std::future提供了一个访问异步操作结果的机制，它和线程是一个级别的属于低层次的对象，在它之上高一层的是 std::packaged_task和std::promise，它们内部都有future以便访问异步操作结果，std::packaged_task包装的是一个异步操作，而std::promise包装的是一个值，都是为了方便异步操作，当需要获取 线程中的某个值时就可以用std::promise，当需要获取一个异步调用操作的返回值时就可以使用std::packaged_task。

用std::async代替线程的创建

std::async是先将异步操作用std::packaged_task包装起来，然后将异步操作的结果放到std::promise中，这个过程就是创造未来的过程。

std::async的原型：

1
async(std::launch::async|std::launch::defered, f, args...),

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

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

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

std::async的基本用法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include <iostream>
#include <future>


int main()
{
	std::future<int> f1 = std::async(std::launch::async, [](){
		return 8;
	});

	std::cout << f1.get() << std::endl; // output : 8

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

	f2.wait(); // output: 8

	std::future<int> future = std::async(std::launch::async, [](){
		std::this_thread::sleep_for(std::chrono::seconds(3));
		return 8;
	});

	std::cout << "waiting...\n";
	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);

	std::cout << "result is " << future.get() << '\n';


return 0;
}

// 可能的结果为：
8
8
waiting...
timeout
timeout
ready!
result is 8

总结：

std::async是更高层次的异步操作，令我们不必关系线程内部细节，不仅方便的获取异步执行状态和结果，还可以指定线程创建策略，应该用std::async替代线程的创建，可以作为我们异步操作的首选。

多谢您的大力支持