C++17并行STL算法实战与性能优化

1. 并行算法与STL的融合背景

现代处理器早已进入多核时代，我的第一台四核电脑还是2006年买的Intel Q6600，如今手机都有8核处理器了。但直到C++17标准，STL才真正开始拥抱并行计算。这背后有个有趣的矛盾：硬件厂商拼命堆核心数，而软件生态却迟迟跟不上。我见过太多代码还在用单线程暴力遍历vector，就像开着跑车却只用一档行驶。

STL（Standard Template Library）作为C++的基石，其算法组件最初设计于90年代，那时对称多处理（SMP）还是服务器专属。2017年MSVC团队做过测试，在16核机器上，对10亿个元素排序，parallel_sort比常规sort快11倍。这个数字现在看可能更高，因为AMD线程撕裂者已经做到96核192线程。

2. 并行化STL算法实战

2.1 执行策略解析

C++17引入了三种执行策略类：

cpp复制std::execution::seq   // 强制顺序执行（传统方式）
std::execution::par   // 允许并行执行
std::execution::par_unseq  // 允许并行+向量化

我在项目中最常用的是par策略。有个坑要注意：并行算法要求迭代器至少是前向迭代器（forward iterator），因为并行执行需要多次遍历容器。去年帮同事调试时发现，他用par策略处理istream_iterator，结果运行时直接core dump。

2.2 典型算法并行化改造

以transform为例，传统写法：

cpp复制std::transform(src.begin(), src.end(), dest.begin(), 
               [](auto x){ return x*2; });

并行版本只需加个执行策略：

cpp复制std::transform(std::execution::par,
              src.begin(), src.end(), dest.begin(),
              [](auto x){ return x*2; });

但这里有个性能陷阱：如果lambda很简单（如上述乘法），线程调度开销可能抵消并行收益。我的经验法则是，当单个元素处理耗时超过500ns时才值得并行化。

3. 并行算法的特殊约束

3.1 线程安全问题

并行算法要求操作必须是线程安全的。我曾踩过这样的坑：

cpp复制int sum = 0;
std::for_each(std::execution::par, vec.begin(), vec.end(),
             [&](auto x){ sum += x; });  // 数据竞争！

正确做法是使用atomic或reduce算法：

cpp复制std::atomic<int> sum{0};
// 或者直接用并行版accumulate
int sum = std::reduce(std::execution::par, vec.begin(), vec.end());

3.2 异常处理机制

并行算法中的异常会触发terminate。解决方案是先在lambda内部捕获：

cpp复制std::vector<int> data = {...};
std::vector<int> result(data.size());
std::transform(std::execution::par, data.begin(), data.end(),
              result.begin(), [](int x) {
                try {
                    return 100/x; 
                } catch(...) {
                    return 0; // 提供默认值
                }
              });

4. 性能优化实战技巧

4.1 数据局部性优化

并行算法可能破坏缓存友好性。这个例子展示错误用法：

cpp复制// 二维数组行优先存储
std::for_each(std::execution::par, 
             rows.begin(), rows.end(),
             [&](auto row) {
                for(auto& elem : row) 
                    process(elem); // 缓存颠簸！
             });

应该改为列块划分：

cpp复制const size_t chunk = rows.size()/std::thread::hardware_concurrency();
for(size_t i=0; i<rows.size(); i+=chunk) {
    auto end = std::min(i+chunk, rows.size());
    std::for_each(std::execution::par,
                 rows.begin()+i, rows.begin()+end,
                 [](auto& row){...});
}

4.2 负载均衡策略

当元素处理时间差异大时，默认的块划分会导致负载不均。可以通过动态任务分配改善：

cpp复制std::mutex mtx;
auto it = data.begin();
std::for_each(std::execution::par, data.begin(), data.end(),
             [&](auto&) {
                std::unique_lock lock(mtx);
                if(it == data.end()) return;
                auto curr = it++;
                lock.unlock();
                process(*curr); // 实际处理
             });

5. 现代C++的并行演进

C++20引入了ranges库后，并行语法更优雅：

cpp复制namespace rv = std::ranges::views;
std::vector<int> result;
std::copy(std::execution::par,
         data | rv::transform(heavy_op),
         std::back_inserter(result));

C++23更是新增了并行算法：

• std::shift_left/std::shift_right
• 并行版的inplace_merge
• 并行化的集合操作

我在最近的项目中实测，用parallel版的set_union处理两个百万级有序集合，比单线程快7倍。但要注意输入必须有序，否则性能反而下降。