C++并发学习笔记（5）：异步与future_c++ futrue对象的管理-优快云博客

本文链接：https://blog.youkuaiyun.com/J1nBa0/article/details/146229447

C++11 引入的异步相关 API 方法和类

API	C++标准	说明
`async`	C++11	异步运行一个函数，并返回一个 `std::future`，用于获取异步任务的结果。
`future`	C++11	用于等待被异步设置的值。通过 `get()` 获取任务结果，或使用 `wait()` 等待任务完成。
`packaged_task`	C++11	将一个函数包装为可异步执行的任务，并存储其结果以供稍后通过 `future` 获取。
`promise`	C++11	用于设置一个值，后续通过与之关联的 `future` 获取该值。通常与 `std::async` 或 `packaged_task` 配合使用。
`shared_future`	C++11	类似于 `std::future`，但可以被多个线程共享。用于多个线程获取同一个异步任务的结果。

1.`std::async` 的基本用法

std::async 用法非常简单，它会自动管理线程的创建和销毁。常见的用法如下：

#include <iostream>
#include <future>

int do_work() {
    std::cout << "Work started in thread\n";
    return 42;
}

int main() {
    // 使用 std::launch::async 启动异步任务
    std::future<int> result_async = std::async(std::launch::async, do_work);

    // 使用 std::launch::deferred 延迟执行任务，只有调用 get 时才会执行
    std::future<int> result_deferred = std::async(std::launch::deferred, do_work);

    // 获取异步任务结果
    std::cout << "Result (async): " << result_async.get() << std::endl;
    
    // 在调用 get 时才会执行异步任务
    std::cout << "Result (deferred): " << result_deferred.get() << std::endl;

    return 0;
}

为什么要用`std::async`？

1. 自动线程管理（Resource Acquisition Is Initialization，RAII）

std::thread：你必须手动管理线程的创建、执行和结束。线程启动后，必须确保在合适的时机调用 join() 或 detach() 来管理线程生命周期，否则可能会导致程序崩溃或资源泄漏。
std::async：由库自动管理线程的生命周期。你不需要显式地创建线程或管理它们，std::async 会返回一个 std::future，并自动在适当的时机启动和结束任务。
std::async 通过 std::future 来隐式管理线程，当你调用 get() 时，程序会等待线程结束并获取结果。你无需手动调用 join()。

2. 自动捕获异步任务异常

std::thread：如果线程中的代码抛出异常，你必须在外部捕获这些异常，或者让线程内部处理。否则，异常可能会丢失。

try {
    std::thread t([]() { throw std::runtime_error("Error!"); });
    t.join();
} catch (const std::exception& e) {
    std::cout << "Caught: " << e.what() << std::endl;
}

如果线程抛出异常并且没有被捕获，程序会终止。
std::async：std::future 会捕获异步任务中的异常，并在调用 get() 时重新抛出，因此你可以更方便地处理异常。

std::future<int> result = std::async(std::launch::async, []() { throw std::runtime_error("Error!"); });
try {
    result.get();
} catch (const std::exception& e) {
    std::cout << "Caught: " << e.what() << std::endl;
}

3. 更灵活的启动策略

std::thread：std::thread 总是启动一个新的线程，你不能控制它是否会在新线程中执行（除非使用线程池或手动管理线程）。
std::async：std::async 允许你选择启动策略（std::launch::async 或 std::launch::deferred）。如果你选择 std::launch::async，它会创建一个新线程；如果你选择 std::launch::deferred，任务会在调用 get() 时推迟执行，并且在调用时由当前线程执行。

4. 性能考虑

std::thread：每次创建新线程时，操作系统需要分配一定的资源。频繁创建和销毁线程会增加开销。
std::async：如果选择 std::launch::async，std::async 会创建一个新线程，但它的实现可能会使用线程池（这依赖于标准库的具体实现）。因此，std::async 在频繁启动小任务时可能比 std::thread 更高效。

2.`std::packaged_task` 的基本用法：

std::packaged_task 是 C++11 引入的一种工具，用于将一个可调用对象（函数、函数对象、lambda 等）包装成一个异步任务，并通过 std::future 获取任务的结果。它与 std::async 和 std::thread 一样，可以用于异步任务的管理，但 packaged_task 提供了更多的灵活性，尤其是在任务调度和控制方面。

将一个函数或者可调用对象封装成一个异步任务。
通过 std::future 获取异步任务的结果。
可以与线程（如 std::thread）结合使用，进行任务调度。

在一些业务中，我们可能会有很多的任务需要调度。这时我们常常会设计出任务队列和线程池的结构。此时，就可以使用packaged_task来包装任务。

packaged_task绑定到一个函数或者可调用对象上。当它被调用时，它就会调用其绑定的函数或者可调用对象。并且，可以通过与之相关联的future来获取任务的结果。调度程序只需要处理packaged_task，而非各个函数。

packaged_task对象是一个可调用对象，它可以被封装成一个std::fucntion，或者作为线程函数传递给std::thread，或者直接调用。

以下是一个简单的示例：

#include <iostream>
#include <cmath>
#include <vector>
#include <thread>
#include <future>
#include <chrono>

const int MAX = 100000;  // 可以根据需要调整最大值

double concurrent_worker(int min, int max) {
    double sum = 0;
    for (int i = min; i <= max; i++) {
        sum += std::sqrt(i);
    }
    return sum;
}

double concurrent_task(int min, int max) {
    std::vector<std::future<double>> results; // ①

    unsigned concurrent_count = std::thread::hardware_concurrency(); // 获取硬件支持的线程数
    int range = (max - min + 1) / concurrent_count; // 每个线程处理的任务范围
    
    for (int i = 0; i < concurrent_count; i++) { // ②
        int start = min + i * range;
        int end = (i == concurrent_count - 1) ? max : start + range - 1; // 最后一个线程处理剩余任务
        
        std::packaged_task<double(int, int)> task(concurrent_worker); // ③
        results.push_back(task.get_future()); // ④

        std::thread t(std::move(task), start, end); // ⑤
        t.detach(); // 让线程异步执行
    }

    std::cout << "Threads created and running..." << std::endl;
    double sum = 0;
    for (auto& r : results) {
        sum += r.get(); // ⑥ 阻塞主线程，等待所有线程执行完毕
    }
    return sum;
}

int main() {
    auto start_time = std::chrono::steady_clock::now(); // 记录开始时间

    double result = concurrent_task(0, MAX); // 执行任务

    auto end_time = std::chrono::steady_clock::now(); // 记录结束时间
    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time).count();
    std::cout << "Concurrent task finished, " << ms << " ms consumed, Result: " << result << std::endl;

    return 0;
}

为什么使用`std::packaged_task`？

1. 线程管理方式：

std::packaged_task 和 std::future：
- 使用 std::packaged_task 来封装函数，它会将任务包装成一个异步操作，且 future 能够获取异步执行的结果。每个线程的执行任务通过 future 获取返回值。线程启动后通过 t.detach() 来异步执行，不需要 join()，从而使得线程独立执行。
- future 主要用于获取线程执行的结果，并同步所有线程的结果。
直接使用 std::thread：
- 通过 std::thread 启动线程并且等待线程执行完毕。使用 std::mutex 来确保多个线程访问共享数据时的线程安全。
- 每个线程计算完自己的部分之后，利用互斥锁将结果安全地写入共享的 results 数组，最终汇总所有线程的计算结果。

2. 锁的使用：

std::packaged_task 和 std::future：
- std::packaged_task 本身不涉及共享数据的写操作，因此不需要额外的锁机制。每个线程的结果通过 future 返回，主线程在 future.get() 时获取线程结果。
直接使用 std::thread：
- 由于线程可能并发修改同一个数据结构（例如 results 数组），需要使用 std::mutex 来确保每个线程对共享数据的修改是安全的。
- std::lock_guard<std::mutex> 确保线程安全地修改共享的 results 数组。

3. `detach()` 和 `join()`：

std::packaged_task 和 std::future：
- 通过 t.detach() 让线程异步运行，即线程会在后台执行，主线程继续向下执行。这意味着主线程与子线程的生命周期不再紧密绑定，主线程通过 future.get() 来获取结果。
- detach 不会阻塞主线程，因此是非阻塞式的。
直接使用 std::thread：
- 使用 t.join() 来等待每个线程的完成，主线程会被阻塞直到所有子线程结束执行。这样，所有线程必须在继续执行主线程之前完成。
- join 是阻塞式的，意味着主线程会在此位置等待，直到所有线程都执行完毕。

4. 异步与同步：

std::packaged_task 和 std::future：
- 由于使用 std::future，线程间的通信是同步的。主线程可以随时调用 future.get() 来获取线程的计算结果，阻塞直到每个线程计算完成并返回结果。
直接使用 std::thread：
- 线程通过共享数组来通信，需要使用 std::mutex 来同步对共享资源的访问。在 join() 之后，主线程会合并所有线程的结果。

5. 使用场景：

std::packaged_task 和 std::future：
- 更适用于需要灵活控制线程生命周期和异步获取结果的场景。使用 future 可以方便地获取每个线程的返回值，而无需显式地管理线程间的同步。
直接使用 std::thread：
- 更适用于需要同步执行的任务，或者需要显式控制线程的创建、执行、同步过程的场景。std::mutex 提供了直接的锁机制来避免竞态条件。

命令模式 (Command Pattern)

命令模式是一种行为设计模式，它将请求封装成一个对象，从而使你可以用不同的请求、队列或者日志来参数化其他对象。它可以将命令的请求者与执行者解耦，使得请求的发送者和接收者之间不需要直接依赖。

命令模式的核心要素：

命令（Command）：封装一个请求或动作，通常是一个类或函数对象，具有 execute() 方法来执行具体的操作。
接收者（Receiver）：实际执行操作的对象，通常是命令对象的目标对象。
调用者（Invoker）：发出命令并请求执行的对象。
客户端（Client）：创建命令并设置接收者的对象。

命令模式通常通过创建命令对象来封装不同的操作，使得客户端可以通过调用 execute() 来触发这些操作。

`std::packaged_task` 与命令模式的关系

行为封装：std::packaged_task 和命令模式都将动作或操作封装在一个对象中。在 std::packaged_task 中，封装的是一个可调用对象（如函数、lambda 表达式或函数对象），而命令模式封装的是一个具体的命令或动作。
延迟执行：在命令模式中，命令对象可能会在未来的某个时刻执行，而不是立即执行。std::packaged_task 也是如此，任务可以被延迟执行，并且可以在将来的某个时间点（如通过线程执行）启动。
解耦：实现了请求者与执行者的解耦。std::packaged_task 可以与 std::thread、std::async 等异步执行机制配合使用，解耦任务的调用和执行时机。

3.`std::promise` 的基本用法

std::promise<double> sum;
std::future<double> result = sum.get_future();

// 其他线程设置 sum 的值
std::thread worker([&sum]() {
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟计算延迟
    sum.set_value(42.0);  // 设置值
});

std::cout << "Waiting for result..." << std::endl;
double final_result = result.get();  // 阻塞，直到 sum 设置值
std::cout << "Result: " << final_result << std::endl;

worker.join();  // 等待工作线程完成

于是用promise优化上述代码

#include <iostream>
#include <cmath>
#include <vector>
#include <thread>
#include <future>
#include <chrono>

const int MAX = 100000;  // 可以根据需要调整最大值

// 执行工作函数
double concurrent_worker(int min, int max) {
    double sum = 0;
    for (int i = min; i <= max; i++) {
        sum += std::sqrt(i);
    }
    return sum;
}

// 并发任务，接受一个 promise 用于返回结果
void concurrent_task(int min, int max, std::promise<double>* result) {
    std::vector<std::future<double>> results; // 用于存储每个线程的 future

    unsigned concurrent_count = std::thread::hardware_concurrency(); // 获取硬件支持的线程数
    int range = (max - min + 1) / concurrent_count; // 每个线程处理的任务范围

    // 创建多个线程并分配任务
    for (int i = 0; i < concurrent_count; i++) {
        int start = min + i * range;
        int end = (i == concurrent_count - 1) ? max : start + range - 1; // 最后一个线程处理剩余任务

        std::packaged_task<double(int, int)> task(concurrent_worker); // 打包任务
        results.push_back(task.get_future()); // 将 future 加入列表

        std::thread t(std::move(task), start, end); // 创建线程
        t.detach(); // 让线程异步执行
    }

    std::cout << "Threads created and running..." << std::endl;
    double sum = 0;
    for (auto& r : results) {
        sum += r.get(); // 等待线程完成并汇总结果
    }

    result->set_value(sum); // 通过 promise 设置最终结果
    std::cout << "concurrent_task finish" << std::endl;
}

int main() {
    auto start_time = std::chrono::steady_clock::now(); // 记录开始时间

    // 创建 promise 用于获取结果
    std::promise<double> sum;
    
    // 执行并发任务
    std::thread task_thread(concurrent_task, 0, MAX, &sum); // 创建任务线程
    task_thread.join(); // 等待任务线程完成

    // 获取计算结果
    double result = sum.get_future().get(); // 获取 promise 设置的值

    auto end_time = std::chrono::steady_clock::now(); // 记录结束时间
    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time).count();

    // 输出结果
    std::cout << "Concurrent task finished, " << ms << " ms consumed." << std::endl;
    std::cout << "Result: " << result << std::endl;

    return 0;
}

为什么不能直接传递 `&sum`：

线程安全问题：
- std::promise 是 非线程安全 的，它不能被多个线程同时访问（除非加锁保护）。如果你直接将 &sum 传递给多个线程，并且多个线程同时访问同一个 promise 对象，就可能导致竞态条件，进而导致未定义行为（比如多个线程尝试设置 set_value 或获取 get）。
生命周期问题：
- 如果你传递的是 &sum，你必须确保 sum 在所有线程结束前都存在。如果 sum 被销毁或者失效（例如主线程结束后），那么线程就会尝试访问一个已经销毁的对象，导致程序崩溃。
  正确做法：应该通过 std::move 将 promise 的所有权传递给线程，这样保证 promise 在每个线程中是唯一且安全的。

4.`std::execution` 的基本用法

这些策略是用来控制并行算法（如 std::for_each 或 std::transform 等）如何执行的。它们的功能如下：

execution::seq (sequenced_policy):
- 表示算法应按顺序执行，即使它的实现是并行的。这是默认行为，要求按顺序执行，不会进行并行化。
execution::par (parallel_policy):
- 指示算法可以并行化执行。编译器或运行时可以决定是否将算法的操作并行执行，但并不要求必然并行化。
execution::par_unseq (parallel_unsequenced_policy):
- 允许算法并行化并向量化（例如，使用 SIMD 指令）。这意味着算法的执行不仅可以并行化，甚至可能在不保留执行顺序的情况下进行优化。

这三种策略使得 C++17 在多核处理器上的性能得到了显著提升，允许开发者更好地控制算法的并行化行为。你有没有考虑在项目中使用这些策略来提升性能呢？

#include <iostream>
#include <vector>
#include <algorithm>
#include <execution>
#include <chrono>
#include <random>

// 随机数据生成函数
void generateRandomData(std::vector<double>& collection, int size) {
    std::random_device rd;
    std::mt19937 mt(rd());
    std::uniform_real_distribution<double> dist(1.0, 100.0);
    for (int i = 0; i < size; i++) {
        collection.push_back(dist(mt));
    }
}

// 测量时间的通用函数
template <typename Callable>
long long measure_time(Callable&& func) {
    auto start = std::chrono::steady_clock::now();
    func();  // 执行传入的可调用对象
    auto end = std::chrono::steady_clock::now();
    return std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
}

int main() {
    std::vector<double> collection;
    generateRandomData(collection, 100 * 1000000); // 生成1亿随机数据

    // 创建数据副本
    std::vector<double> copy1(collection); 
    std::vector<double> copy2(collection);
    std::vector<double> copy3(collection);
    std::vector<double> copy4(collection); // 用于不加执行策略的排序

    // 测量默认顺序排序的时间
    long long default_sort_time = measure_time([&]() {
        std::sort(copy1.begin(), copy1.end());  // 不加执行策略
    });
    std::cout << "Default sort (no policy) consuming " << default_sort_time << "ms." << std::endl;

    // 测量顺序排序的时间
    long long seq_sort_time = measure_time([&]() {
        std::sort(std::execution::seq, copy2.begin(), copy2.end());
    });
    std::cout << "Sequenced sort consuming " << seq_sort_time << "ms." << std::endl;

    // 测量并行排序的时间
    long long par_sort_time = measure_time([&]() {
        std::sort(std::execution::par, copy3.begin(), copy3.end());
    });
    std::cout << "Parallel sort consuming " << par_sort_time << "ms." << std::endl;

    // 测量无序并行排序的时间
    long long par_unseq_sort_time = measure_time([&]() {
        std::sort(std::execution::par_unseq, copy4.begin(), copy4.end());
    });
    std::cout << "Parallel unsequenced sort consuming " << par_unseq_sort_time << "ms." << std::endl;

    return 0;
}

结果分析

排序策略	适用情况	预期性能
默认排序	小数据集、单线程环境	性能相对较慢，不适合大数据集
顺序排序 (`std::execution::seq`)	无需并行、避免并行开销	性能与默认排序接近，但不能利用多核
并行排序 (`std::execution::par`)	大数据集、多核计算机	对于大数据集，比顺序排序要快
无序并行排序 (`std::execution::par_unseq`)	大数据集、高并发，硬件支持优化	在多核系统上可能最快，但不保证稳定

实际性能比较

小数据集: 对于小规模的数据（例如几万或几十万的元素），这些排序策略之间的差异可能不大，因为排序操作的时间相对较短，并行化带来的开销不会显现出来。
大数据集: 对于像 1 亿数据这么大的数据集，std::execution::par 和 std::execution::par_unseq 会有明显的性能提升，特别是在多核 CPU 上。std::execution::par_unseq 可能会更快，但要注意它不保证排序稳定性。