C++ 多线程std::async

std::async

        对于线程的创建，我们可以直接用thread，但是这会有很多的不便，比如获取子进程的返回值，解决方案是定义一个变量，然后将变量的指针传入到子进程中，然后对其进行赋值，但终归是不便。

        除此之外我们可以用std::async函数来创建一个进程;

        std::async的函数原型：

template<class Fn, class... Args>
future<typename result_of<Fn(Args...)>::type> async(launch policy, Fn&& fn, Args&&...args);

其中第一个参数决定执行策略是同步的还是异步的，

1：std::launch::async 传递的可调用对象是异步执行的；

2：std::launch::deferred 传递的可调用对象是同步执行的；

3：std::launch::async | std::launch::deferred 可以异步或是同步，取决于操作系统，我们无法控制；

4：缺省为（3）

注意点

future的参数是传入的可调用对象的返回值类型，且每一个std::async的函数都会返回一个右值futrue对象。

注意点

std::async返回的future对象一定要被接受，否则会报错；

注意点

当我们选择std::launch::deferred策略时，只有我们调用future的get函数，对应的线程才会启动，并返回结果，也可以用wait函数，但是wait函数的返回值是void；

std::future

我们可以通过future的get、wait_for、wait函数对子线程的结果和状态进行访问；

1：get

template <class T> get()

在调用子线程的get函数时会阻塞主线程，并返回结果；

2：wait_for

std::future_status wait_for(std::chrono::milliseconds);

3：wait

void wait();

我们传入参数，表示等待这个线程多久，等待过程有两个状态

-：在等待过程的某一个时刻，线程执行完成，返回std::future_status::ready

-：在整个等待刚才中，线程没有执行完成，返回std::future_status::timeout

-：检测到线程未开始，返回std::future::deferred

看下面代码

std::future_status测试

#include<future>
#include<iostream>
#include<thread>
using namespace std;

void outStatus(std::future_status status) {

	if (status == std::future_status::ready)
	{
		cout << "线程执行完" << endl;
	}
	else if (status == std::future_status::timeout)
	{
		cout << "线程超时" << endl;
	}
	else if (status == std::future_status::deferred)
	{
		cout << "线程延迟执行" << endl;
	}
}

int myThread() {
	cout << "Thread id " << this_thread::get_id() << "isstart" << endl;
	this_thread::sleep_for(chrono::milliseconds(5s));
	cout << "Thread id " << this_thread::get_id() << " isover" << endl;
	return 5;
}

int middle() {
	future<int> result = async(launch::async, myThread);
	cout << "wait for\n";
	future_status status = result.wait_for(std::chrono::milliseconds(6s));
	outStatus(status);
	cout << "wait over" << endl;
	return 5;
}

int main() {
	future<int> result = async(launch::async,middle);
	int x; cin >> x;

}

我们开启一个子线程A，并在子线程A中开两个子线程B、C，B、C的任务时间耗费的都是5s，但B等待6s，C等待4s，另外D线程中我们用deferred策略；

运行结果

 注意点：

如果我们不接住[将std::async的右值返回值给保存到生命周期符合需求的std::future对象]，那么在future析构的过程中，会等待线程结束，如果我们用的是std::launch::async策略的话，那么直接析构对象会导致直接等待线程，从而导致异步效果消失；

这也解释了线程类不能进行左值拷贝