C++17标准中定义了三种执行策略:
std::execution::sequenced_policy
std::execution::parallel_policy
std::execution::parallel_unsequenced_policy
(译者注：C++20中添加了unsequenced_policy策略)
相应的策略标定了程序应该串行、并行，还是与向量化并行。
std::execution::seq: 串行执行
std::execution::par: 多线程并行执行
std::execution::par_unseq: 多个线程上并行，可以循环交叉，也能使用SIMD(单指令多数据)
std::execution::par或std::execution::par_unseq允许算法并行或向量化并行。
下面的代码片段展示了所有执行策略的使用方式。
#include <execution>
#include <vector>
#include <algorithm>
int main() {
std::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
// standard sequential sort
std::sort(v.begin(), v.end());
// sequential execution
std::sort(std::execution::seq, v.begin(), v.end());
// permitting parallel execution
std::sort(std::execution::par, v.begin(), v.end());
//permitting parallel and vectorized execution
std::sort(std::execution::par_unseq, v.begin(), v.end());
}
示例中，可以使用经典的std::sort(第11行)。C++17中，可以明确指定使用方式：串行(第14行)、并行(第17行)，还是向量化并行(第20行)。
std::is_execution_policy可以检查模板参数T是标准数据类型，还是执行策略类型：std::is_execution_policy<T>::value。如果T是std::execution::sequenced_policy, std::execution::parallel_policy, std::execution::parallel_unsequenced_policy，或已定义的执行策略类型，则表达式结果为true；否则，为false。
并行和向量化执行
算法是否以并行和向量化的方式运行，取决于许多因素。例如：CPU和编译器是否支持SIMD指令，还取决于编译器实现和代码的优化级别。
下面的示例使用循环填充数组。
#include <iostream>
const int SIZE = 8;
int vec[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
int res[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
int main() {
for (int i = 0; i < SIZE; ++i) {
res[i] = vec[i] + 5;
}
for (int i = 0; i < SIZE; ++i) {
std::cout << res[i] << " ";
}
std::cout << std::endl;
}
第12行是这个示例中的关键。我们可以在compiler explorer看一下clang 3.6生成的相应汇编指令。
无优化
汇编指令中，每个加法都是串行进行的。
使用最高优化级别
通过使用最高的优化级别-O3，寄存器(如：xmm0)可以容纳128位，或者说是4个整型数字。这样，加法就可以同时在四个元素进行了。
无执行策略算法的重载，与具有串行执行策略std::execution::seq算法的重载在异常处理方面有所不同。
异常
如果执行策略的算法发生异常，将调用std::terminate。std::terminate调用std::terminate_handler，之后使用std::abort，让异常程序终止。执行策略的算法与调用std::execution::seq执行策略的算法之间没有区别。无执行策略的算法会传播异常，因此可以对异常进行处理。exceptionExecutionPolicy.cpp可以佐证我的观点。
// exceptionExecutionPolicy.cpp
#include <algorithm>
#include <execution>
#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>
int main() {
std::cout << std::endl;
std::vector<int> myVec{ 1,2,3,4,5 };
try {
std::for_each(myVec.begin(), myVec.end(),
[](int) {throw std::runtime_error("Without execution policy"); }
);
}
catch (const std::runtime_error & e) {
std::cout << e.what() << std::endl;
}
try {
std::for_each(std::execution::seq, myVec.begin(), myVec.end(),
[](int) {throw std::runtime_error("With execution policy"); }
);
}
catch (const std::runtime_error & e) {
std::cout << e.what() << std::endl;
}
catch (...) {
std::cout << "Catch-all exceptions" << std::endl;
}
}
第21行可以捕获异常std::runtime_error，但不能捕获第30行中的异常，甚至在第33行中的捕获全部异常也无法捕获相应的异常。
使用新的MSVC编译器，并开启std:c++latest选项，程序会给出期望的输出。
只有第一个异常顺利捕获。
数据竞争和死锁的风险
并行算法无法避免数据竞争和死锁。
下面的并行代码中，就存在数据竞争。
#include <execution>
#include <vector>
int main() {
std::vector<int> v = { 1, 2, 3 };
int sum = 0;
std::for_each(std::execution::par, v.begin(), v.end(), [&sum](int i) {
sum += i + i;
});
}
代码段中，sum有数据竞争。sum上累加了i + i的和，并且是并发修改的，所以必须保护sum。
#include <execution>
#include <vector>
#include <mutex>
std::mutex m;
int main() {
std::vector<int> v = { 1, 2, 3 };
int sum = 0;
std::for_each(std::execution::par, v.begin(), v.end(), [&sum](int i) {
std::lock_guard<std::mutex> lock(m);
sum += i + i;
});
}
将执行策略更改为std::execution::par_unseq时，会出现条件竞争，并导致死锁。
#include <execution>
#include <vector>
#include <mutex>
std::mutex m;
int main() {
std::vector<int> v = { 1, 2, 3 };
int sum = 0;
std::for_each(std::execution::par_unseq, v.begin(), v.end(), [&sum](int i) {
std::lock_guard<std::mutex> lock(m);
sum += i + i;
});
}
同一个线程上，Lambda函数可能连续两次调用m.lock，这会产生未定义行为，大多数情况下会导致死锁。这里，可以使用原子来避免死锁。
#include <execution>
#include <vector>
#include <mutex>
#include <atomic>
std::mutex m;
int main() {
std::vector<int> v = { 1, 2, 3 };
std::atomic<int> sum = 0;
std::for_each(std::execution::par_unseq, v.begin(), v.end(), [&sum](int i) {
std::lock_guard<std::mutex> lock(m);
sum += i + i;
});
}
因为sum是一个原子计数器，所以将语义放宽也没关系：sum.fetch_add(i * i, std::memory_order_relaxed) .
执行策略可以作为参数传入69个STL重载算法中，以及C++17添加的8个新算法中。
