C++ future/promise/thread/async/packaged_task入门

Fireplusplus

已于 2024-01-11 22:14:41 修改

阅读量889

点赞数 22

文章标签： c++ promise future thread async packaged_task

于 2024-01-11 21:18:59 首次发布

本文链接：https://blog.csdn.net/qq_33724710/article/details/135537746

版权

std::promise、future、thread、async、packaged_task这些到底是个啥？

两种获取异步结果的方式

std::future

std::future是一个同步原语，它代表了一个异步操作的结果。这个结果可能来自另一个线程、任务或者异步操作，而std::future提供了一种机制来访问这个结果。std::future通常与std::async、std::promise或std::packaged_task一起使用。
std::future对象封装了一个值，这个值在将来某个时刻才会变得可用。当异步操作完成时，它的结果（或异常）会存储在std::future对象中。可以通过std::future对象来检索这个结果，或者等待异步操作完成。

获取std::future
可以通过以下几种方式获取std::future对象：

通过std::async启动一个异步任务时，它会返回一个std::future对象。
通过调用std::promise对象的get_future方法。
通过std::packaged_task对象的get_future方法。

使用std::future获取结果

get()方法用来获取存储在其中的值。如果异步操作还没有完成，get方法会阻塞当前线程，直到值变得可用。调用完get，feature对象不再持有该结果。
wait()方法用来等待异步操作完成，而不获取结果

异常处理
如果异步操作抛出了异常，这个异常会被捕获并存储在std::future对象中。当你调用get方法时，异常会被重新抛出。

try {
    int x = fut.get();
} catch (std::exception& e) {
    // 处理异常
}

std::future对象在默认构造时不关联任何异步操作。只有当它与一个特定的异步操作关联后，它才变得有用。std::future对象是不可复制的，但它们可以被移动。这意味着你可以将它们从一个函数传递到另一个函数，但不能创建它们的副本。

通过std::future，开发者可以轻松地管理异步操作的结果，无论是来自std::async启动的任务，还是std::promise和std::packaged_task的结果。std::future提供了一种安全且简单的方式来同步线程间的操作，使得编写并发和异步代码变得更加容易和安全。

std::promise

std::promise是一个同步原语，它提供了一种在一个线程中存储一个值或异常，并在另一个线程中通过std::future对象来检索它的机制。std::promise和std::future通常一起使用，以在线程间传递数据或通知。

创建std::promise

#include <chrono>
#include <thread>
#include <future>

using namespace std;

void SlowAdd(int a, int b, promise<int>&& p) {
    this_thread::sleep_for(std::chrono::seconds(1));
	p.set_value(a + b);
}

int main() {
	promise<int> p;
    // 与每个std::promise对象关联的是一个std::future对象
	future<int> f = p.get_future();

	thread t(SlowAdd, 1, 2, move(p));
	cout << f.get() << endl;

	t.join();

	return 0;
}

输出：

code % ./a.out       
3  // after 1 sec

异常处理
如果在计算过程中发生异常，你可以使用std::promise的set_exception方法来存储异常：

try {
    // 执行一些可能抛出异常的计算
} catch (...) {
    myPromise.set_exception(std::current_exception());
}

在另一个线程中，当你尝试通过std::future对象获取结果时，如果有异常被存储，它将被重新抛出。std::promise对象一旦通过set_value或set_exception设置了值或异常，就不能再次设置，否则将会抛出std::future_error异常。

此外，std::promise对象在析构时会自动释放与之关联的资源，但如果你在析构前没有设置值或异常，与之关联的std::future对象在调用get()时将抛出std::future_error异常。

两种异步执行任务的方式

std::thread

std::thread代表了一个单独的执行线程。创建一个std::thread对象时，你可以传递一个函数或者任何可调用对象（包括lambda表达式、函数指针、成员函数指针和具有operator()的对象）给它，这个函数或对象将在新线程中执行。

创建线程

#include <iostream>
#include <chrono>
#include <thread>

using namespace std;

void Add(int a, int b) {
	cout << "sum: " << a + b << endl;
}

class C_Sub {
public:
	void Sub(int a, int b) {
		cout << "sub: " << a - b << endl;
	}
};

int main() {
	thread t1(Add, 1, 2);
	t1.join();

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

	C_Sub sub;
	thread t2(&C_Sub::Sub, sub, 3, 2);
	t2.join();

	return 0;
}

输出：

code % ./a.out       
sum: 3
sub: 1

线程管理
创建线程后，就需要管理它的生命周期。通常，你需要在某个时刻等待线程结束，这可以通过调用join()来实现。如果你没有在std::thread对象销毁前调用join()或者detach()，或者重复调用了join()或detach()，那么在其析构函数中会调用std::terminate()，程序将异常终止。

join()：等待线程结束。
detach()：允许线程独立运行，即使创建它的std::thread对象已经被销毁。
joinable(): 判断一个thread是否是可join或detach的，即没有调用过join或detach

线程与异常
如果线程函数抛出了一个未捕获的异常，std::terminate()将被调用，程序将终止。因此，你应该确保线程函数中的异常被妥善处理。

std::async

std::async是一个函数模板，它用于异步执行一个任务，并返回一个std::future对象。这个std::future对象可以用来获取异步任务的结果。std::async可以选择立即启动一个新线程来执行任务，也可以延迟执行任务直到对应的std::future对象的get()或wait()被调用。

使用std::async启动异步任务

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

using namespace std;

int SlowAdd(int a, int b) {
    this_thread::sleep_for(std::chrono::seconds(1));
	return a + b;
}

int main() {
	future<int> f = async(SlowAdd, 1, 2);
	cout << f.get() << endl;
	return 0;
}

输出：

code % ./a.out       
3  // after 1 sec

std::async的启动策略
std::async可以接受一个可选的启动策略参数，这个参数控制异步任务的执行方式。

std::launch::async：指示std::async创建一个新线程来立即执行任务。
std::launch::deferred：指示std::async延迟执行任务，直到调用std::future对象的get()或wait()。

如果不指定启动策略，std::async可能会根据实现选择最合适的策略。

异步任务的异常处理
如果异步任务抛出了异常，这个异常不会立即传播到启动任务的线程。相反，异常会被存储在std::future对象中，当你调用get()来获取结果时，异常会被重新抛出。

std::async与std::thread的比较
std::async与std::thread都可以用来执行并发任务，区别：

std::async返回一个std::future对象，可以用来获取任务的结果或异常，而std::thread不直接提供这样的机制。
std::async管理任务的生命周期，当std::future对象被销毁时，它会等待任务完成。而std::thread需要显式地调用join()或detach()。
std::async可以延迟执行任务，而std::thread总是立即启动一个新线程。

一种绑定feature与任务的方式

std::packaged_task

std::packaged_task是C++11引入的一个模板类，它封装了一个可调用对象（如函数、lambda表达式、绑定表达式或其他函数对象），并允许其异步执行。它的一个关键特性是能够提供一个std::future对象，通过这个对象可以在未来某个时刻获取std::packaged_task所封装的可调用对象的返回值。

如何使用std::packaged_task

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

using namespace std;

int SlowAdd(int a, int b) {
    this_thread::sleep_for(std::chrono::seconds(1));
	return a + b;
}

int main() {
    std::packaged_task<int(int)> task(SlowAdd);
    std::future<int> f = task.get_future();

    std::thread t(std::move(task), 1, 2);
    std::cout << f.get() << std::endl;

    t.join();
    return 0;
}

输出：