如何优化Parallel STL嵌套并行设计以提升线程利用率？

你遇到的核心问题是Parallel STL嵌套并行时的线程资源分配矛盾：外层迭代数过少时，内层并行无法利用空闲线程；外层迭代数充足时，内层并行会与外层抢占线程池资源，导致整体效率低下。以下是几种基于Parallel STL的无感优化方案：

1. 任务扁平化：统一调度所有嵌套任务 #

最直接的解决思路是消除嵌套结构，将两层循环的任务合并为单一的扁平化任务队列，让Parallel STL统一调度所有任务，从根源上避免资源竞争。

你可以封装一个nested_for_each函数，自动将外层每个元素的内层序列拼接成全局视图，再用par_unseq执行：

#include <ranges>
#include <execution>
#include <algorithm>

template <typename OuterRange, typename InnerGetter, typename Func>
void nested_for_each(std::execution::parallel_unsequenced_policy policy,
                     OuterRange&& outer_range, InnerGetter&& get_inner, Func&& op)
{
    // 生成扁平化视图：将所有内层元素拼接为连续序列
    auto flattened = std::views::join(std::views::transform(outer_range, get_inner));
    std::for_each(policy, flattened.begin(), flattened.end(), std::forward<Func>(op));
}

使用时直接替换原有的嵌套for_each：

// 替换原嵌套代码
nested_for_each(std::execution::par_unseq, begin, end,
                [](auto i) { return std::ranges::subrange(i->begin(), i->end()); },
                [](auto j) { g(j); });

这种方式对业务逻辑侵入极小，几乎是无感替换，且所有任务由Parallel STL统一调度，线程利用率能达到最大值。

2. 启用任务窃取调度器（依赖Parallel STL后端实现） #

主流Parallel STL实现（如Intel Parallel STL、GCC libstdc++）底层多依赖TBB（Threading Building Blocks）的任务窃取调度器。如果你的环境默认未启用TBB，只需链接TBB库，par_unseq就会自动切换到任务窃取模式。

在该模式下，外层并行任务执行到内层par_unseq时，会生成可被窃取的子任务——空闲线程会主动抓取这些子任务执行，而非闲置。比如外层仅2个迭代时，这2个线程执行到内层循环后，剩余14个线程会窃取内层子任务，充分利用所有CPU核心。

只需确保编译时链接TBB（GCC加-ltbb，MSVC添加TBB项目依赖），无需修改代码即可自动优化嵌套并行的线程利用率。

3. 动态切换执行策略：根据迭代数智能选择并行/串行 #

如果不想依赖第三方库，可以封装一个智能版for_each，根据当前迭代数和总线程数动态选择执行策略：

#include <execution>
#include <algorithm>
#include <thread>

template <typename Iter, typename Func>
void smart_parallel_for_each(Iter begin, Iter end, Func&& op)
{
    const auto total_threads = std::thread::max_concurrency();
    const auto iteration_count = std::distance(begin, end);

    if (iteration_count < total_threads / 2) {
        // 外层迭代数过少，串行执行外层，让内层并行可使用全量线程
        std::for_each(std::execution::seq, begin, end, std::forward<Func>(op));
    } else {
        // 外层迭代数充足，并行执行外层，内层改用串行避免资源竞争
        std::for_each(std::execution::par_unseq, begin, end,
            [&op](auto&& elem) {
                std::for_each(std::execution::seq, elem->begin(), elem->end(), op);
            });
    }
}

使用时直接替换外层的std::for_each即可，内层逻辑会根据策略自动调整，避免线程资源浪费，且无需依赖第三方库，兼容性更好。

4. 异步提交嵌套任务：手动分散调度 #

如果以上方案不适用，可以将内层并行任务异步提交到全局线程池，外层仅负责提交任务，最后统一等待结果：

#include <execution>
#include <algorithm>
#include <future>
#include <vector>

// 外层代码改造
std::vector<std::future<void>> tasks;
tasks.reserve(std::distance(begin, end));

std::for_each(std::execution::seq, begin, end, [&](auto i) {
    tasks.emplace_back(std::async(std::launch::async, [i]() {
        std::for_each(std::execution::par_unseq, i->begin(), i->end(), g(j));
    }));
});

// 等待所有内层任务完成
for (auto& task : tasks) {
    task.get();
}

这种方式让所有内层并行任务由全局线程池统一调度，无论外层迭代数多少，都能充分利用所有可用线程。缺点是需要手动管理异步任务，代码侵入性稍大，但灵活性更高。

内容的提问来源于stack exchange，提问作者user2961927