C++17 std::execution策略详解与实战应用
执行策略的核心目的
在现代多核架构上，并行算法通过将工作划分为独立任务来同时在多个核心上执行，从而显著提升吞吐量与处理能力。不过并行并非万无一失，开销、数据依赖和内存带宽竞争等因素会抵消部分收益。因此，理解执行策略的语义、粒度和实现细节，是实现高效并行的前提。
C++17 引入的执行策略为标准算法提供了显式的并行化途径，核心策略包括串行、并行以及并行无序三种类型。通过合理选择策略，可以在保证正确性的前提下，最大化硬件资源的利用率。策略的选择需要结合数据特征、算法特性以及硬件环境，并非越并行越好。
下面给出一个简要示例，演示如何在 std::transform 中应用并行策略；请注意，实际效果取决于编译器实现和硬件支持。
#include <algorithm>
#include <vector>
#include <execution>
#include <iostream>int main() {std::vector<int> a(1'000'000, 2);std::vector<int> b(1'000'000);std::transform(std::execution::par, a.begin(), a.end(), b.begin(),[](int x){ return x * x; });std::cout << "done" << std::endl;return 0;
}
三类执行策略的含义及差异
在进行并行化设计时，需清楚三类核心策略的行为差异：seq表示按顺序执行，par表示可并行地对数据区间执行，而 par_unseq 则允许对同一数据区间进行无序并行，可能在某些场景下获得更高的向量化程度。理解这三种策略的语义，是避免数据竞争与结果不确定性的关键。
对于并行策略，最常见的模式是把数据集分割成若干子区间，独立执行一个函数对象，然后再合并结果。适度的粒度划分有助于降低上下文切换成本，同时避免缓存竞争和内存带宽瓶颈。在数据独立且无共享状态的情况下，使用 par 可以显著提升性能。
有时，数据依赖或副作用使得使用强并行策略变得困难，此时应回退到 seq 或使用最小必要的并行性。下面的代码展示了对同一数据集应用不同策略的对比，帮助判断在具体场景下的收益点。
并行策略在排序与变换中的实用性
很多算法天然具备可并行性，如大规模向量运算、数组变换、分区聚合等。以排序为例，有序输出的需求与内存访问模式直接影响并行化的收益。对于不可改变的序列，使用 std::sort(std::execution::par, ...) 可以在多核上分发排序任务，提升吞吐的同时保持正确性，但必须关注分区边界和缓存友好性。
非线性、带依赖的计算往往不宜直接并行，需要通过局部无冲突的操作或使用并行友好的数据结构来实现。以下代码给出一个排序的并行化示例，展示如何在现实场景中应用执行策略来提升性能。
常用执行策略及其含义
串行执行（std::execution::seq）
串行执行遵循严格的顺序执行，适用于存在强数据依赖、复杂副作用或对输出顺序有严格要求的场景。虽然看似性能最差，但它的正确性和可预测性最好，且开销最小。对于小型数据集或对并行化成本高于收益的场景，使用 seq 可以避免不必要的并行化开销。安全性优先，但在大规模数据上往往不满足性能目标。
在实际应用中，当算法存在显式的顺序依赖、全局锁或不可并行的外部状态时，seq 是最可靠的选择。若要在部分阶段保持顺序，可将数据拆分后对每一段使用 seq，并在外部进行合并。
并行执行（std::execution::par）
并行执行允许算法对数据区间进行并行处理，核心目标是提升吞吐量。对独立且无副作用的变换、拷贝和聚合等操作，par 能显著降低总执行时间，尤其是在数据规模较大、CPU 核数充足时。并行性与正确性之间的权衡在此处非常重要，因为并行带来的潜在竞争可能导致难以复现的结果。
在使用 par 时，需避免对同一数据区域进行读写冲突，尽量让每个任务拥有独立的工作区。例如对向量执行变换并写入不同输出区，或对只读数据执行聚合。若数据结构包含共享状态，需额外的同步机制来避免数据竞争。
并行无序执行（std::execution::par_unseq）
par_unseq 允许对数据进行无序、甚至矢量化的并行执行，是追求极致性能时的高阶选项。它依赖编译器和硬件的向量化能力，可能实现更高的吞吐，但对算法要求更高，且并非所有实现都对所有算法都支持。对副作用和不可重入代码尤其要谨慎，以免产生未定义行为。
在使用 par_unseq 的场景中，数据访问模式应尽量是独立的、没有依赖的，并且尽量避免两端数据的交叉写入。对于纯粹的数值变换和单纯的筛选/聚合等操作，par_unseq 可以带来显著的加速。
实战应用：并行算法提升性能的具体案例
案例一：大规模向量元素平方和的快速计算
当处理规模达到数百万的向量时，单线程的平方运算会成为瓶颈。利用执行策略的并行能力，可以把向量分块并行计算，再进行全局聚合。核心原则是确保每个子任务对输出区没有写入冲突，同时聚合阶段要线程安全。
目标是降低总执行时间，同时避免竞态条件；通过使用 par 策略对 transform 进行平方操作，能显著提高吞吐量。
#include <algorithm>
#include <vector>
#include <execution>
#include <numeric>
#include <iostream>int main() {std::vector<double> v(2'000'000, 3.14);std::vector<double> w(2'000'000);// 1) 并行化的变换std::transform(std::execution::par, v.begin(), v.end(), w.begin(),[](double x){ return x * x; });// 2) 并行化的求和double sum = std::reduce(std::execution::par, w.begin(), w.end(), 0.0);std::cout << "sum=" << sum << std::endl;return 0;
}
案例二：大规模排序的并行优化
排序是数据处理中常见且对并行性敏感的操作。将数据分段后，分别在各自分区内进行排序，再合并结果，是一个常见的并行化思路。使用 std::sort(std::execution::par, ...) 可以在多核环境中提升排序吞吐量，前提是数据分布均匀且写入是无竞争的。
需要关注的点包括分区边界的处理、最终合并成本以及是否存在分治后的合并瓶颈。对于已经预排序或者部分有序的数据，使用并行策略往往并不会带来数量级的提升，反而可能增加开销。
#include <algorithm>
#include <vector>
#include <execution>
#include <random>
#include <iostream>int main() {std::vector<int> data(1'000'000);// 产生随机数据std::mt19937 rng(123);std::uniform_int_distribution<int> dist(0, 1000000);for (auto &x : data) x = dist(rng);// 并行排序std::sort(std::execution::par, data.begin(), data.end());std::cout << "sorted" << std::endl;return 0;
}
案例三：矩阵-向量乘法的并行化策略
在科学计算和图形处理场景，矩阵-向量乘法是一种典型的可并行化工作负载。通过把矩阵的行作为独立任务，使用 par 或 par_unseq 进行并行计算，可以有效缩短计算时间。需要注意缓存友好性和行与列的访问模式，以降低缓存未命中的成本。
下面是一个简单的实现示例，展示如何对每一行并行计算点积：
#include <vector>
#include <execution>
#include <numeric>int main() {const std::size_t M = 1024, N = 1024;std::vector<std::vector<double>> A(M, std::vector<double>(N, 1.0));std::vector<double> x(N, 1.0);std::vector<double> y(M, 0.0);// 行级并行计算 y = A * xstd::for_each(std::execution::par, A.begin(), A.end(), [&](const std::vector<double> &row) {std::size_t i = &row - &A[0];y[i] = std::inner_product(row.begin(), row.end(), x.begin(), 0.0);});return 0;
}
性能调优与常见陷阱
粒度与任务划分的艺术
合理的粒度是提升并行性的重要前提。粒度过细会造成线程切换和同步成本上升，反而降低性能；粒度过粗则可能导致负载不均、某些核心空闲。通过对数据分区大小进行基准测试，找到一个在目标硬件上折中的粒度，是常见的实战做法。
在实际场景中，可以通过分区数与核心数的关系来估算初始粒度，并结合动态负载平衡策略进行微调。基准化测试是必不可少的环节，以确保不同实现版本之间的可比性。
缓存、内存带宽与竞争
并行化会带来更多的并行内存访问，缓存行对齐、数据局部性和内存带宽容量成为决定性因素。若任务在同一时间访问相邻数据， cache 亲和性将显著提升性能；反之，伪共享和内存带宽瓶颈会拖慢系统。
为降低风险，尽量避免在同一输出区写入产生竞争，使用独立的输出缓冲区，或通过对齐与结构化绑定来提升缓存利用率。对于大规模数据，优先考虑分块处理与流式访问模式。
副作用与线程安全
并行算法的安全性取决于是否存在副作用、可重复性和数据竞争。若一个函数对象包含对全局状态的修改、或对同一数据区域进行写操作，需使用同步原语或重新设计为无副作用的纯函数。无副作用的变换和聚合通常更易并行化，有助于提升稳定的性能。
在实际开发中，建议用最小可重入的设计来实现并行逻辑，尽量避免共享状态的写入。对需要共享的数据，使用原子操作或锁机制进行控制，确保结果可预测。
