C++中如何使用 std::execution::par 对 STL 容器进行并行操作的技巧

2026-01-17 作者 stdcpp

在 C++17 及以后，标准库为 STL 容器的算法提供了并行化的执行策略，最常用的即 std::execution::par。通过它可以在多核 CPU 上自动将大规模数据处理任务分块并行执行，从而显著提升性能。下面我们从基础使用、性能调优、调试与兼容性等方面进行系统梳理，帮助你在项目中灵活掌握并行算法。

1. 并行执行策略简介

策略	含义	线程数	适用场景
`std::execution::seq`	顺序执行	1	代码需要严格顺序或数据规模小
`std::execution::par`	并行执行	取决于系统，通常与核心数相同	大量独立迭代、无共享写
`std::execution::par_unseq`	并行+向量化	取决于系统	既需要并行又需要 SIMD 向量化

注意：并行策略并不保证一定加速，反而在小规模或 I/O 密集型任务中可能导致性能下降。

2. 基础使用示例

#include <algorithm>
#include <execution>
#include <vector>
#include <numeric>
#include <iostream>

int main() {
    const size_t N = 10'000'000;
    std::vector <int> data(N, 1);

    // 并行求和
    long long sum = std::reduce(
        std::execution::par,          // 并行执行
        data.begin(), data.end(),
        0LL,
        std::plus<>{}
    );

    std::cout << "sum = " << sum << '\n';
    return 0;
}

关键点

算法必须满足：T 的拷贝构造/移动构造要快速；迭代器是随机访问的；没有跨线程的数据冲突。
返回值：并行算法仍然返回同类型对象，和顺序算法一致。

3. 典型并行算法列表

算法	说明	并行实现示例
`std::for_each`	对每个元素执行函数	`std::for_each(std::execution::par, ...)`
`std::transform`	生成新序列	`std::transform(std::execution::par, ...)`
`std::sort`	排序	`std::sort(std::execution::par, ...)`
`std::partition`	重新排列	`std::partition(std::execution::par, ...)`
`std::reduce`	归约	`std::reduce(std::execution::par, ...)`
`std::accumulate`	旧版本不支持并行，改用 `std::reduce`

只有 std::for_each, std::transform, std::sort, std::partition, std::reduce 等已在标准库中声明支持 par。其它如 std::accumulate 需要自己改写。

4. 性能调优技巧

技巧	说明	代码示例
避免不必要的拷贝	将算法的操作目标设为引用类型	`std::for_each(par, data.begin(), data.end(), [](auto &x){ x += 1; });`
使用更细粒度的数据结构	`std::vector` 比 `std::list` 更适合并行	`std::vector
v;`
开启编译器优化	`-O3 -march=native -ffast-math`	编译命令：`g++ -O3 -march=native -std=c++20 main.cpp -lpthread`
手动分块	对超大数据手动划分区块并行	`std::vector<std::future<void>> futures;`
利用 `std::execution::par_unseq`	对 SIMD+并行合并	`std::transform(std::execution::par_unseq, ...)`

4.1 手动分块示例

#include <future>
#include <thread>
#include <vector>

template<typename Func>
void parallel_for(size_t n, Func f) {
    const size_t num_threads = std::thread::hardware_concurrency();
    const size_t chunk = n / num_threads;
    std::vector<std::future<void>> fs;
    for(size_t i = 0; i < num_threads; ++i) {
        size_t start = i * chunk;
        size_t end   = (i == num_threads - 1) ? n : start + chunk;
        fs.emplace_back(std::async(std::launch::async, [=]{
            for(size_t j = start; j < end; ++j) f(j);
        }));
    }
    for(auto &fut : fs) fut.get();
}

5. 并行编程的陷阱与排查

陷阱	说明	排查方法
数据竞争	多线程写同一内存	使用 `std::atomic` 或 `mutex`，或改用不可变对象
分区不均衡	负载不均导致性能损失	统计各线程工作量，调整分块策略
过多线程	线程上下文切换开销大	`std::thread::hardware_concurrency()` 与 `omp_set_num_threads`
异常传播	异常抛出后多线程同步不确定	用 `try-catch` 包裹任务并记录错误
调试困难	并行代码不易复现	通过 `OMP_WAIT_POLICY=passive` 或 `-fsanitize=thread`

6. 与第三方库的配合

Intel Threading Building Blocks (TBB)：提供更细粒度的任务调度与分块策略。
OpenMP：在编译器支持时，可以用 #pragma omp parallel for 实现相似效果。
PThreads：底层实现更细粒度的控制，适用于高性能服务器。

7. 兼容性与平台差异

平台	编译器	备注
GCC 11+	支持 `std::execution::par`	默认使用 `libstdc++` 并行实现
Clang 12+	支持	需要链接 `-lpthread`
MSVC 19.29+	支持	需要开启 `/std:c++20`
macOS	默认 libstdc++	并行支持相对成熟
Linux	大多数发行版	对多核支持最佳

在某些旧版编译器（GCC < 11）或特定环境中，std::execution 可能未实现，导致编译错误。此时可改用第三方实现或手工分块。

8. 小结

并行算法 为 C++ 提供了高层次的并行抽象，使用 std::execution::par 可以在保持代码可读性的同时获得多核加速。
适用场景：大规模独立迭代、无共享写、可重入的算法。
性能提升 需要结合 数据结构、编译器优化、手工分块 等多种手段。
调试与稳定 关注 数据竞争、异常处理 与 线程数控制。

通过本文的示例与技巧，你可以在自己的项目中快速引入并行算法，提升 CPU 资源利用率，并为未来更复杂的并行任务奠定基础。祝编码愉快！

发表评论取消回复