使用C++ STL并行算法时的线程专属变量问题

你的测试是否有效？ #

有效。cppreference仅规定带执行策略的STL并行算法要求函数对象可拷贝构造，但并未强制要求为每个线程拷贝一份函数对象实例——具体的拷贝策略属于实现定义行为。你在VS环境下观察到的结果，说明该STL实现选择了复用同一个functor实例（或仅在必要时拷贝，而非每个线程一份），这完全符合标准要求。

替代thread_local的解决方案 #

如果不想依赖thread_local的静态生存期，可考虑以下几种方案：

1. 手动分区处理 #

绕开STL并行算法的自动调度，手动将数据划分为多个块，为每个块分配独立线程并在线程内创建缓冲区：

#include <vector>
#include <thread>
#include <algorithm>

int main() {
    std::vector<int> y(10, 5);
    const size_t num_threads = std::thread::hardware_concurrency();
    const size_t chunk_size = y.size() / num_threads;

    std::vector<std::thread> threads;
    for (size_t i = 0; i < num_threads; ++i) {
        auto start = y.begin() + i * chunk_size;
        auto end = (i == num_threads - 1) ? y.end() : start + chunk_size;
        threads.emplace_back([start, end]() {
            std::vector<int> buffer{10}; // 每个线程一份缓冲区
            for (auto it = start; it != end; ++it) {
                // 使用buffer处理*it
            }
        });
    }

    for (auto& t : threads) t.join();
    return 0;
}

这种方式完全控制缓冲区的生命周期，仅在线程处理块数据时存在，线程结束即销毁。

2. 按数据块分配缓冲区（C++20+） #

利用C++20的std::views::chunk将数据分块，并行处理每个块时创建缓冲区——每个块对应一个缓冲区，减少内存分配次数（一个线程可能处理多个块，但远少于每次迭代分配）：

#include <vector>
#include <algorithm>
#include <ranges>

struct ChunkFunctor {
    void operator()(const std::ranges::chunk_view<std::vector<int>::view>& chunk) {
        std::vector<int> buffer{10}; // 每个块一份缓冲区
        for (int val : chunk) {
            // 使用buffer处理val
        }
    }
};

int main() {
    std::vector<int> y(10, 5);
    auto chunks = y | std::views::chunk(y.size() / std::thread::hardware_concurrency());
    std::for_each(std::execution::par, chunks.begin(), chunks.end(), ChunkFunctor{});
    return 0;
}

3. 线程安全的缓冲区缓存 #

使用线程ID作为键，维护一个线程到缓冲区的映射，通过互斥锁保证线程安全。缓冲区会在并行算法结束后统一销毁，避免thread_local的长期存活：

#include <vector>
#include <algorithm>
#include <unordered_map>
#include <mutex>
#include <thread>

struct CachedFunctor {
    void operator()(int const&) {
        std::lock_guard<std::mutex> lock(mtx);
        auto& buffer = thread_buffers[std::this_thread::get_id()];
        if (buffer.empty()) buffer.resize(10); // 延迟初始化
        // 使用buffer处理元素
    }

    ~CachedFunctor() {
        // 并行算法结束后，销毁所有缓冲区
        thread_buffers.clear();
    }

private:
    std::mutex mtx;
    std::unordered_map<std::thread::id, std::vector<int>> thread_buffers;
};

int main() {
    std::vector<int> y(10, 5);
    std::for_each(std::execution::par, y.begin(), y.end(), CachedFunctor{});
    return 0;
}

注意：该方案的锁会带来一定性能开销，适合缓冲区初始化成本远高于锁开销的场景。

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