什么是 ‘Execution Policies’？利用 `std::execution::par` 让 STL 算法自动并行化

C++ STL 算法的自动并行化：深入理解 Execution Policies 与 std::execution::par

各位编程领域的同仁，大家好！

在现代计算环境中，多核处理器已成为标配。如何有效地利用这些核心，将程序的执行速度推向新的高度，是每个C++开发者必须面对的挑战。传统的多线程编程，如直接使用 std::thread、OpenMP 或 Intel TBB 等，虽然强大，但往往伴随着复杂的线程管理、同步机制和潜在的并发错误。这无疑增加了开发的难度和出错的风险。

C++17 标准为我们带来了“执行策略”（Execution Policies），为STL算法的并行化提供了一种优雅、声明式且标准化的解决方案。它允许我们以一种更高级别、更安全的方式来表达算法的并行意图，将底层的并行化实现细节交给编译器和运行时库。今天，我们的重点将放在其中最常用且功能强大的策略之一：std::execution::par，它能让STL算法自动地在多个线程上并行执行。

什么是 Execution Policies？

执行策略（Execution Policies）是C++17引入的一组类型，它们作为STL算法的第一个参数，用于指定该算法如何被执行。其核心思想是将“做什么”（算法逻辑）与“如何做”（执行方式）解耦。通过引入执行策略，我们可以告诉编译器和运行时库：这个算法可以顺序执行，也可以并行执行，甚至可以并行且无序地执行。

这种设计哲学带来了显著的优势：

1. 简化并行编程：开发者无需手动创建和管理线程，只需选择合适的策略。
2. 提高可移植性：策略是标准化的，不同编译器和平台可以提供各自优化的实现。
3. 提升性能潜力：允许编译器和运行时根据硬件特性和负载动态选择最佳的并行化方案。
4. 清晰的意图表达：代码直接声明了算法的并行化意图，增强了可读性。

C++标准库定义了四种主要的执行策略：

• std::execution::seq：顺序执行策略。算法将按照严格的顺序在单个线程上执行。这是传统STL算法的默认行为，也是最安全的策略，因为没有并发性问题。
• std::execution::par：并行执行策略。算法被允许在多个线程上并发执行。各个操作的相对顺序可能是不确定的，但每个操作的效果必须与顺序执行时相同。此策略旨在利用多核处理器。
• std::execution::unseq：无序执行策略。算法被允许在单个线程上，但以一种“无序”的方式执行，这意味着允许对指令进行矢量化（SIMD）和乱序执行，以提高单线程性能。操作之间的相对顺序可能不保留。
• std::execution::par_unseq：并行无序执行策略。这是 par 和 unseq 的结合。算法被允许在多个线程上并发执行，并且每个线程内部的操作也可能以无序的方式执行。这提供了最高的性能潜力，但对用户提供的操作有最严格的要求。

这四种策略并非互斥，而是性能与约束之间的权衡。下表总结了它们的关键特性：

策略名称	描述	是否并行执行？	是否允许乱序执行/矢量化？	性能潜力	适用场景
std::execution::seq	严格顺序执行。	否	否	基础	调试、小数据集、I/O密集型、共享状态复杂
std::execution::par	允许在多个线程上并发执行。	是	否 (对每个元素)	高	CPU密集型、大数据集、独立操作、易于管理并发安全
std::execution::unseq	允许在单个线程上乱序执行（SIMD）。	否	是	中高	CPU密集型、小而紧密的循环、单线程性能优化
std::execution::par_unseq	允许在多个线程上并发，且每个线程内允许乱序执行（SIMD）。	是	是	最高	CPU密集型、大数据集、独立操作、严格的数学属性保证

深入 std::execution::par：让STL算法自动并行化

std::execution::par 策略是我们今天关注的重点。当我们将 std::execution::par 作为STL算法的第一个参数时，我们实际上是在告诉编译器和运行时库：“嘿，这个算法中的每个独立操作都可以并行地执行，你尽管放手去优化吧！”。这意味着，对于像 std::for_each、std::transform、std::sort 这样的算法，它们的内部迭代或操作可能会被拆分成多个任务，并在不同的线程上同时执行。

核心原理： 编译器和库实现会检测算法的并行性，并可能使用线程池等机制来调度任务。例如，一个 std::for_each 遍历一个包含一百万个元素的向量，如果使用 std::execution::par，库可能会将这个向量分成若干个子范围，然后为每个子范围分配一个线程来处理。

关键考量：数据竞争 (Data Races)

虽然 std::execution::par 策略让并行化变得简单，但它并不能魔术般地解决所有并发问题。最重要的一点是：它不能防止数据竞争。 如果你提供的操作（例如 lambda 表达式或函数对象）访问或修改了共享的可变状态而没有适当的同步机制，那么当你使用 std::execution::par 时，你将面临未定义行为（Undefined Behavior），这通常表现为程序崩溃、结果不正确或难以复现的Bug。

什么是数据竞争？
当至少两个线程同时访问同一个内存位置，并且至少其中一个访问是写入操作，同时没有同步机制来协调这些访问时，就发生了数据竞争。

为了安全地使用 std::execution::par，你必须确保：

1. 独立操作：算法中的每个操作都是独立的，不依赖于其他操作的中间结果，或者对共享数据的访问是只读的。
2. 线程安全：如果算法中的操作需要访问或修改共享的可变状态，你必须使用适当的同步机制，例如 std::mutex、std::atomic 或其他线程安全的数据结构。

让我们通过一些代码示例来具体说明。

实践示例：安全与不安全的并行化

示例1：安全的 std::for_each (独立操作)

假设我们有一个包含大量数字的向量，我们想对每个数字执行一个独立且不修改外部状态的操作。

#include <iostream>
#include <vector>
#include <algorithm>
#include <execution> // 包含执行策略
#include <chrono>    // 用于计时
#include <numeric>   // 用于 std::iota

void process_element(int& n) {
    // 模拟一些计算密集型工作
    for (int i = 0; i < 1000; ++i) {
        n = n * 2 / 2 + 1 - 1; // 简单的计算，不改变最终值，仅消耗CPU
    }
}

int main() {
    const int num_elements = 1000000;
    std::vector<int> data(num_elements);
    std::iota(data.begin(), data.end(), 0); // 用0到num_elements-1填充向量

    // 复制一份数据用于并行版本，避免修改原始数据影响顺序版本的测试
    std::vector<int> data_par = data;

    // --- 顺序执行 ---
    auto start_seq = std::chrono::high_resolution_clock::now();
    std::for_each(std::execution::seq, data.begin(), data.end(), process_element);
    auto end_seq = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration_seq = end_seq - start_seq;
    std::cout << "Sequential execution time: " << duration_seq.count() << " secondsn";

    // --- 并行执行 ---
    auto start_par = std::chrono::high_resolution_clock::now();
    std::for_each(std::execution::par, data_par.begin(), data_par.end(), process_element);
    auto end_par = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration_par = end_par - start_par;
    std::cout << "Parallel execution time:   " << duration_par.count() << " secondsn";

    // 验证结果（在此例中，process_element不改变数值，所以验证data_par[0]和data[0]是相同的）
    // 但更重要的是，所有元素的处理都完成了
    if (data[0] == data_par[0]) {
        std::cout << "Results are consistent (for first element).n";
    } else {
        std::cout << "Results are INCONSISTENT!n";
    }

    return 0;
}

在这个例子中，process_element 函数只修改其传入参数的局部副本（实际上是 data 向量中的一个元素），并且不访问任何共享的外部状态。因此，每个元素的处理都是独立的，非常适合并行化。在多核系统上，你会看到并行版本的执行时间明显少于顺序版本。

示例2：安全的 std::transform (转换操作)

std::transform 是另一个非常适合并行化的算法，因为它通常将一个范围的元素转换为另一个范围，每个转换都是独立的。

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

// 转换函数：将数字平方
int square(int n) {
    return n * n;
}

int main() {
    const int num_elements = 5000000;
    std::vector<int> input(num_elements);
    std::iota(input.begin(), input.end(), 1); // 填充 1 到 num_elements

    std::vector<int> output_seq(num_elements);
    std::vector<int> output_par(num_elements);

    // --- 顺序执行 ---
    auto start_seq = std::chrono::high_resolution_clock::now();
    std::transform(std::execution::seq, input.begin(), input.end(), output_seq.begin(), square);
    auto end_seq = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration_seq = end_seq - start_seq;
    std::cout << "Sequential transform time: " << duration_seq.count() << " secondsn";

    // --- 并行执行 ---
    auto start_par = std::chrono::high_resolution_clock::now();
    std::transform(std::execution::par, input.begin(), input.end(), output_par.begin(), square);
    auto end_par = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration_par = end_par - start_par;
    std::cout << "Parallel transform time:   " << duration_par.count() << " secondsn";

    // 验证结果
    bool consistent = true;
    for (int i = 0; i < num_elements; ++i) {
        if (output_seq[i] != output_par[i]) {
            consistent = false;
            break;
        }
    }
    if (consistent) {
        std::cout << "Results are consistent.n";
    } else {
        std::cout << "Results are INCONSISTENT!n";
    }

    return 0;
}

std::transform 将 input 向量的每个元素平方，并将结果写入 output 向量。由于每个元素的转换都是独立的，并且写入不同的目标位置，因此没有数据竞争，std::execution::par 可以安全地使用。

示例3：安全的 std::sort (经典的并行问题)

排序是另一个非常适合并行化的算法，因为现代并行排序算法（如并行归并排序或并行快速排序）能够有效地利用多核。

#include <iostream>
#include <vector>
#include <algorithm>
#include <execution>
#include <chrono>
#include <random> // 用于生成随机数

int main() {
    const int num_elements = 10000000;
    std::vector<int> data_seq(num_elements);
    std::vector<int> data_par(num_elements);

    // 填充随机数据
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> distrib(1, num_elements);
    for (int i = 0; i < num_elements; ++i) {
        data_seq[i] = distrib(gen);
    }
    data_par = data_seq; // 复制一份用于并行排序

    // --- 顺序排序 ---
    auto start_seq = std::chrono::high_resolution_clock::now();
    std::sort(std::execution::seq, data_seq.begin(), data_seq.end());
    auto end_seq = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration_seq = end_seq - start_seq;
    std::cout << "Sequential sort time: " << duration_seq.count() << " secondsn";

    // --- 并行排序 ---
    auto start_par = std::chrono::high_resolution_clock::now();
    std::sort(std::execution::par, data_par.begin(), data_par.end());
    auto end_par = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration_par = end_par - start_par;
    std::cout << "Parallel sort time:   " << duration_par.count() << " secondsn";

    // 验证结果
    if (data_seq == data_par) {
        std::cout << "Results are consistent.n";
    } else {
        std::cout << "Results are INCONSISTENT!n";
    }
    // 进一步验证是否真的排序
    if (std::is_sorted(data_par.begin(), data_par.end())) {
        std::cout << "Parallel sorted vector is indeed sorted.n";
    }

    return 0;
}

std::sort 的并行版本通常会采用分治策略，将数组分成多个子数组并行排序，然后再合并。由于标准库的 std::sort 实现会保证其正确性，所以我们可以安全地使用 std::execution::par。

示例4：安全的 std::reduce (并行求和)

std::reduce 是 std::accumulate 的并行版本，用于对范围内的元素执行归约操作（例如求和、求积）。要安全地并行化，其二元操作必须满足结合律和交换律。

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

int main() {
    const int num_elements = 50000000;
    std::vector<long long> data(num_elements);
    std::iota(data.begin(), data.end(), 1LL); // 填充 1 到 num_elements

    // --- 顺序求和 (使用 std::accumulate 作为对比) ---
    auto start_seq_acc = std::chrono::high_resolution_clock::now();
    long long sum_seq_acc = std::accumulate(data.begin(), data.end(), 0LL);
    auto end_seq_acc = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration_seq_acc = end_seq_acc - start_seq_acc;
    std::cout << "Sequential accumulate time: " << duration_seq_acc.count() << " seconds, sum: " << sum_seq_acc << "n";

    // --- 顺序求和 (使用 std::reduce, 策略为 seq) ---
    auto start_seq_red = std::chrono::high_resolution_clock::now();
    long long sum_seq_red = std::reduce(std::execution::seq, data.begin(), data.end(), 0LL);
    auto end_seq_red = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration_seq_red = end_seq_red - start_seq_red;
    std::cout << "Sequential reduce time:     " << duration_seq_red.count() << " seconds, sum: " << sum_seq_red << "n";

    // --- 并行求和 (使用 std::reduce, 策略为 par) ---
    auto start_par_red = std::chrono::high_resolution_clock::now();
    long long sum_par_red = std::reduce(std::execution::par, data.begin(), data.end(), 0LL);
    auto end_par_red = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration_par_red = end_par_red - start_par_red;
    std::cout << "Parallel reduce time:       " << duration_par_red.count() << " seconds, sum: " << sum_par_red << "n";

    // 验证结果
    if (sum_seq_acc == sum_par_red) {
        std::cout << "Results are consistent.n";
    } else {
        std::cout << "Results are INCONSISTENT! Expected " << sum_seq_acc << ", got " << sum_par_red << "n";
    }

    return 0;
}

求和操作 (+) 是结合律和交换律的，因此 std::reduce 可以安全地并行化。并行版本会把数据分成几块，每块独立求和，最后将所有部分的和再相加。

示例5：不安全的 std::for_each (数据竞争)

现在我们来看一个会导致数据竞争的例子。假设我们想计算一个向量中所有元素的总和，并尝试使用 std::for_each 和一个外部变量来累加结果。

#include <iostream>
#include <vector>
#include <algorithm>
#include <execution>
#include <chrono>
#include <numeric>
#include <atomic> // 用于修复数据竞争

int main() {
    const int num_elements = 1000000;
    std::vector<int> data(num_elements);
    std::iota(data.begin(), data.end(), 1); // 填充 1 到 num_elements

    long long total_sum_unsafe = 0;
    std::atomic<long long> total_sum_safe = 0; // 使用 std::atomic 修复

    // 计算期望的总和 (顺序版本，用于验证)
    long long expected_sum = 0;
    for (int i = 1; i <= num_elements; ++i) {
        expected_sum += i;
    }
    std::cout << "Expected sum: " << expected_sum << "n";

    // --- 不安全的并行求和 (数据竞争) ---
    // 多个线程同时写入 total_sum_unsafe，会发生数据竞争
    std::cout << "n--- UNSAFE Parallel Sum ---n";
    total_sum_unsafe = 0; // 重置
    auto start_unsafe = std::chrono::high_resolution_clock::now();
    std::for_each(std::execution::par, data.begin(), data.end(),
                  [&](int n) {
                      total_sum_unsafe += n; // 数据竞争！
                  });
    auto end_unsafe = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration_unsafe = end_unsafe - start_unsafe;
    std::cout << "Unsafe parallel sum: " << total_sum_unsafe << ", time: " << duration_unsafe.count() << " secondsn";
    if (total_sum_unsafe != expected_sum) {
        std::cout << "WARNING: Unsafe sum is INCORRECT due to data race!n";
    } else {
         std::cout << "NOTE: Unsafe sum *might* be correct by chance, but is still UB.n";
    }

    // --- 安全的并行求和 (使用 std::atomic 修复) ---
    // std::atomic 提供了原子操作，保证了并发写入的正确性
    std::cout << "n--- SAFE Parallel Sum (with std::atomic) ---n";
    total_sum_safe = 0; // 重置
    auto start_safe = std::chrono::high_resolution_clock::now();
    std::for_each(std::execution::par, data.begin(), data.end(),
                  [&](int n) {
                      total_sum_safe += n; // 原子操作，线程安全
                  });
    auto end_safe = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration_safe = end_safe - start_safe;
    std::cout << "Safe parallel sum:   " << total_sum_safe << ", time: " << duration_safe.count() << " secondsn";
    if (total_sum_safe == expected_sum) {
        std::cout << "SUCCESS: Safe sum is CORRECT.n";
    } else {
        std::cout << "ERROR: Safe sum is INCORRECT!n";
    }

    return 0;
}

在“不安全的并行求和”部分，多个线程会同时尝试读取 total_sum_unsafe、增加它的值，然后再写回去。这个“读取-修改-写入”序列不是原子操作，导致不同的线程可能会覆盖彼此的更新，从而得到一个错误的总和。

在“安全的并行求和”部分，我们使用了 std::atomic<long long>。std::atomic 变量提供了原子操作，确保了 total_sum_safe += n; 这个操作在并发环境下是线程安全的，即不会发生数据竞争。虽然原子操作通常比非原子操作慢，但它是确保正确性的必要手段。对于求和这种归约操作，更推荐使用 std::reduce，它在内部会处理好并行求和的同步问题，通常效率更高。

示例6：不安全的 std::for_each (输出竞争)

另一个常见的并发问题是多个线程同时写入共享资源，例如 std::cout。虽然这不一定会导致程序崩溃，但输出内容可能会混乱交错。

#include <iostream>
#include <vector>
#include <algorithm>
#include <execution>
#include <mutex> // 用于修复输出竞争

std::mutex cout_mutex; // 全局互斥锁，保护 std::cout

void print_value_unsafe(int n) {
    // 多个线程同时写入 std::cout，输出可能交错
    std::cout << "Unsafe: " << n << " ";
}

void print_value_safe(int n) {
    std::lock_guard<std::mutex> lock(cout_mutex); // 锁定互斥锁，确保独占访问
    std::cout << "Safe: " << n << " ";
}

int main() {
    std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    std::cout << "--- Unsafe Parallel Print (Output Race) ---n";
    std::for_each(std::execution::par, data.begin(), data.end(), print_value_unsafe);
    std::cout << "n"; // 换行以分隔输出

    std::cout << "n--- Safe Parallel Print (with std::mutex) ---n";
    std::for_each(std::execution::par, data.begin(), data.end(), print_value_safe);
    std::cout << "n";

    return 0;
}

在不安全版本中，你可能会看到输出如 "Unsafe: 1 Unsafe: 3 Unsafe: 2 Unsafe: 4 …" 这样乱序或交错的。而在安全版本中，由于 std::lock_guard 确保了每次只有一个线程能够访问 std::cout，输出将会是顺序的（尽管元素的处理顺序可能仍然不确定，但每个元素的完整输出是原子性的）。当然，这种锁机制会严重降低并行性能，因此在并行代码中应尽量避免对共享资源的频繁锁定。

理解其他执行策略

虽然 std::execution::par 是最常用的并行策略，但了解其他策略的用途也很有价值。

std::execution::seq：顺序执行策略

这是所有STL算法的默认行为，也是最安全、最容易调试的策略。当你不确定并行化是否合适，或者数据量太小以至于并行化的开销大于收益时，应使用 seq。

std::execution::unseq：无序执行策略

unseq 策略允许算法在单个线程上以乱序的方式执行，例如利用SIMD（Single Instruction, Multiple Data）指令集进行矢量化。这意味着一个操作可能同时处理多个数据元素。为了实现这一点，编译器可能会重新排序操作，或者将多个操作打包成一个指令。

使用 unseq 的条件：

• 操作是独立的，不依赖于彼此的顺序。
• 操作是可重入的，没有副作用，或者副作用在乱序执行下也是可接受的。
• 通常用于数学密集型、计算量大的操作，例如矩阵运算、图像处理。

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

void add_scalar(float& f, float scalar) {
    f += scalar;
}

int main() {
    const int num_elements = 10000000;
    std::vector<float> data(num_elements, 1.0f);
    const float scalar_val = 2.5f;

    std::vector<float> data_unseq = data;

    // --- 顺序执行 ---
    auto start_seq = std::chrono::high_resolution_clock::now();
    std::for_each(std::execution::seq, data.begin(), data.end(), 
                  [&](float& f){ add_scalar(f, scalar_val); });
    auto end_seq = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration_seq = end_seq - start_seq;
    std::cout << "Sequential execution time: " << duration_seq.count() << " secondsn";

    // --- 无序执行 (SIMD) ---
    auto start_unseq = std::chrono::high_resolution_clock::now();
    std::for_each(std::execution::unseq, data_unseq.begin(), data_unseq.end(), 
                  [&](float& f){ add_scalar(f, scalar_val); });
    auto end_unseq = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration_unseq = end_unseq - start_unseq;
    std::cout << "Unsequenced execution time: " << duration_unseq.count() << " secondsn";

    // 验证结果
    if (data[0] == data_unseq[0]) {
        std::cout << "Results are consistent (for first element).n";
    } else {
        std::cout << "Results are INCONSISTENT!n";
    }

    return 0;
}

在支持SIMD的硬件和编译器优化下，unseq 版本可能会比 seq 版本更快，即使它只使用一个线程。

std::execution::par_unseq：并行无序执行策略

这是最激进的策略，结合了 par 和 unseq 的优势，旨在提供最高的性能。算法可以在多个线程上并行执行，并且每个线程内的操作也可能被矢量化和乱序执行。

使用 par_unseq 的条件：

• 满足 par 的所有条件（无数据竞争）。
• 满足 unseq 的所有条件（操作独立、可重入、无副作用或副作用可接受乱序）。
• 通常要求操作是结合律和交换律的，因为操作的顺序和组合方式可能会完全改变。

例如，对于浮点数加法，严格来说它不是结合律的（(a + b) + c 不总是等于 a + (b + c)，因为浮点数精度问题），所以在 par_unseq 下进行浮点数求和可能会得到与 seq 略有不同的结果。如果这种微小的差异是不可接受的，则应避免使用 par_unseq。

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

int main() {
    const int num_elements = 50000000;
    std::vector<float> data(num_elements);
    std::iota(data.begin(), data.end(), 1.0f); // 填充 1.0f 到 num_elements.0f

    // --- 顺序求和 ---
    auto start_seq = std::chrono::high_resolution_clock::now();
    float sum_seq = std::reduce(std::execution::seq, data.begin(), data.end(), 0.0f);
    auto end_seq = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration_seq = end_seq - start_seq;
    std::cout << "Sequential reduce time: " << duration_seq.count() << " seconds, sum: " << sum_seq << "n";

    // --- 并行无序求和 ---
    auto start_par_unseq = std::chrono::high_resolution_clock::now();
    float sum_par_unseq = std::reduce(std::execution::par_unseq, data.begin(), data.end(), 0.0f);
    auto end_par_unseq = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration_par_unseq = end_par_unseq - start_par_unseq;
    std::cout << "Par_unseq reduce time:  " << duration_par_unseq.count() << " seconds, sum: " << sum_par_unseq << "n";

    // 验证结果 (注意浮点数比较的误差)
    if (std::abs(sum_seq - sum_par_unseq) < 1e-5) { // 允许一定误差
        std::cout << "Results are consistent (within tolerance).n";
    } else {
        std::cout << "Results are INCONSISTENT! Expected " << sum_seq << ", got " << sum_par_unseq << "n";
    }

    return 0;
}

在这个例子中，par_unseq 可能会提供最快的求和速度，但由于浮点数的特性，结果与 seq 版本可能会有微小的差异。对于大多数科学计算，这种差异通常在可接受的范围内。

何时选择哪种策略？

这是一个实践性的问题，没有一劳永逸的答案，但我们可以给出一些指导原则：

场景/问题类型	推荐策略	理由
默认/安全第一	std::execution::seq	始终正确，易于调试，并行化开销可能不值得。
CPU密集型，大数据集	std::execution::par	有望显著加速，且只要确保无数据竞争即可。
I/O密集型	std::execution::seq (或手动线程，非STL算法)	I/O通常是瓶颈，并行CPU运算意义不大，甚至可能因争夺I/O资源而变慢。
小数据集	std::execution::seq	并行化（线程创建、调度、同步）的开销可能超过并行带来的收益。
数据竞争复杂，难以消除	std::execution::seq	避免未定义行为。如果必须并行，则需手动设计复杂的同步机制，而非依赖STL算法自动并行。
数学密集型，元素独立，对浮点误差不敏感	std::execution::par_unseq (或 unseq for single-thread)	理论上最高性能，充分利用多核和SIMD。
调试并发问题	std::execution::seq	切换到顺序模式可以消除并发导致的复杂性，帮助定位逻辑错误。
算法内部操作包含锁或原子操作	std::execution::par (或 seq)	锁的开销可能抵消并行优势。如果锁竞争严重，并行反而更慢。需要仔细衡量。

性能考量与注意事项

虽然执行策略简化了并行编程，但要真正发挥其性能潜力，还需要考虑以下几点：

1. 并行化开销：线程的创建、销毁、调度、同步以及缓存一致性维护都需要时间。如果算法的工作量太小，这些开销可能会抵消并行带来的收益，甚至导致程序变慢。这被称为粒度问题。
2. Amdahl定律：程序的性能提升受限于其可并行部分的比例。如果你的程序大部分时间都在执行不可并行化的串行任务，那么即使并行化了很小一部分，整体性能提升也会非常有限。
3. 负载均衡：如果并行任务的分配不均匀，一些线程可能很快完成，而另一些线程则长时间运行，导致CPU核心未能充分利用。标准库的实现会尽力做到负载均衡，但极端情况下仍需注意。
4. 数据局部性与缓存：并行执行可能导致不同线程访问内存中不连续的数据，或者产生伪共享（false sharing）现象，即不同线程修改不同变量，但这些变量恰好位于同一个缓存行中，导致缓存频繁失效，反而降低性能。
5. 调试复杂性：并行程序中的Bug（尤其是数据竞争、死锁、活锁等）往往难以复现和调试。使用执行策略虽然减少了手动线程管理的错误，但数据竞争的风险依然存在。
6. 硬件依赖：并行化的实际性能提升高度依赖于你的CPU核心数量、缓存大小、内存带宽以及编译器对特定硬件的优化能力。

最佳实践

• 从 seq 开始：始终从 std::execution::seq 开始编写和测试算法，确保其逻辑正确性。
• 识别并行化热点：使用性能分析工具（profiler）找出程序中耗时最长、且具有并行化潜力的部分。
• 确保线程安全：这是使用并行策略的基石。对于共享的可变状态，要么避免访问，要么使用 std::atomic 或 std::mutex 进行保护。
• 优先使用标准算法：尽可能使用像 std::reduce、std::transform 这样已经针对并行化进行优化的标准算法，而不是自己实现并行循环。
• 最小化共享状态：设计算法时，尽量让每个并行任务在其局部数据上操作，减少对共享状态的访问。如果必须共享，考虑使用不可变数据结构。
• 测试并发性：在不同的负载和硬件配置下测试并行代码，以发现潜在的并发问题。模糊测试（fuzzing）或使用线程分析工具（如Intel Inspector、Helgrind）可以帮助发现数据竞争。
• 始终进行性能测量：不要盲目地认为并行化总是更快。在实际部署环境中测量性能，并与顺序版本进行比较，以验证并行化是否带来了预期的收益。

展望

C++20 及后续标准继续在并发领域发力，引入了协程、std::jthread 等新特性，以及对执行策略更广泛的支持，例如 std::mdspan 与并行算法的结合，使得多维数组的并行处理更加方便。执行策略是C++在迈向现代并发编程道路上的重要一步，它通过将并行化的复杂性封装在标准库中，显著降低了开发者利用多核硬件的门槛。

结语

C++的执行策略，特别是 std::execution::par，为我们提供了一种强大而简洁的工具，以声明式的方式实现STL算法的自动并行化。它让开发者能够更专注于业务逻辑本身，而非繁琐的线程管理。然而，力量越大，责任越大。理解并妥善处理数据竞争，是驾驭并行化的核心。通过遵循最佳实践和深入理解其工作原理，我们便能在多核时代编写出既高效又健壮的C++程序。