使用Intel C++ 2025编译器编译多线程代码时出现内存违规问题求助

各位大佬好，我最近在用Intel C++ 2025编译器编译自己的多线程代码时碰到了内存违规的问题，在GCC和Clang环境下跑都正常，但Intel编译器编译后运行就时不时崩，折腾好几天没找到问题，来求助大家帮忙排查下！

我实现了一个单例模式的线程池，再套了一层单例的Advisor类来管理线程池的生命周期，还有一个并行计算平均值的函数，下面是我的代码：

线程池头文件（ThreadPool.h） #

#ifndef THREAD_POOL_H
#define THREAD_POOL_H
#include <future>
#include <thread>
#include "concurrent_queue.h"
#include <chrono>

class ThreadPool {
public:
    using Task = std::packaged_task<bool(void)>;
    using TaskHandle = std::future<bool>;

private:
    // 单例实例
    static ThreadPool instance_;
    // 任务队列
    concurrent_queue<Task> concurrent_queue_;
    // 线程集合
    std::vector<std::thread> threads_;
    // 活跃状态标识
    bool is_active_;
    // 中断标识
    bool interrupt_;
    // 线程本地存储的线程编号
    static thread_local size_t my_tls_num_;

    // 线程执行函数
    void threadFunc(const size_t num) {
        my_tls_num_ = num;
        // 循环取任务执行，直到队列被清空
        while (auto t = concurrent_queue_.pop()) {
            (*t)();
        }
    }

    // 私有构造函数，确保单例
    ThreadPool() : is_active_(false), interrupt_(false) {}

public:
    // 获取单例实例
    static ThreadPool* getInstance() {
        return &instance_;
    }

    // 获取线程数量
    size_t numThreads() const {
        return threads_.size();
    }

    // 获取当前调用线程的编号
    static size_t threadNum() {
        return my_tls_num_;
    }

    // 启动线程池
    void start(const size_t nThread = std::thread::hardware_concurrency() - 1) {
        if (!is_active_) // 确保只启动一次
        {
            threads_.reserve(nThread);
            for (size_t i = 0; i < nThread; i++) {
                std::thread loc = std::thread(&ThreadPool::threadFunc, this, i + 1);
                threads_.push_back(std::move(loc));
            }
            is_active_ = true;
        }
    }

    // 析构函数
    ~ThreadPool() {
        stop();
    }

    // 停止线程池
    void stop() {
        if (is_active_) {
            interrupt_ = true;
            concurrent_queue_.interrupt();
            // 等待所有线程退出
            for_each(threads_.begin(), threads_.end(), std::mem_fn(&std::thread::join));
            threads_.clear();
            concurrent_queue_.clear();
            concurrent_queue_.reset_interrupt();
            is_active_ = false;
            interrupt_ = false;
        }
    }

    // 禁用拷贝和移动
    ThreadPool(const ThreadPool& rhs) = delete;
    ThreadPool& operator=(const ThreadPool& rhs) = delete;
    ThreadPool(ThreadPool&& rhs) = delete;
    ThreadPool& operator=(ThreadPool&& rhs) = delete;

    // 提交任务
    template<typename Callable>
    TaskHandle spawnTask(Callable c) {
        Task t(std::move(c));
        TaskHandle f = t.get_future();
        concurrent_queue_.push(std::move(t));
        return f;
    }

    // 主动等待future时，顺便执行队列中的任务
    bool activeWait(const TaskHandle& f) {
        using namespace std::chrono_literals;
        bool b = false;
        while (f.wait_for(0s) != std::future_status::ready) {
            if (auto t = concurrent_queue_.try_pop()) {
                (*t)();
                b = true;
            } else {
                f.wait();
            }
        }
        return b;
    }
};

inline ThreadPool ThreadPool::instance_;
inline thread_local size_t ThreadPool::my_tls_num_ = 0;

#endif//THREAD_POOL_H

Advisor单例类 #

#include <mutex>
#include "ThreadPool.h"
#include "func.h"

class Advisor {
private:
    static Advisor * pinstance_;
    static std::mutex mutex_;

protected:
    Advisor(const size_t nThread = std::thread::hardware_concurrency() - 1) {
        ThreadPool::getInstance()->start(nThread);
    }

    virtual ~Advisor() {
        ThreadPool::getInstance()->stop();
    }

public:
    // 禁用拷贝和移动
    Advisor(const Advisor& rhs) = delete;
    Advisor& operator=(const Advisor& rhs) = delete;
    Advisor(Advisor&& rhs) = delete;
    Advisor& operator=(Advisor&& rhs) = delete;

    static Advisor* GetInstance(const size_t nThread = std::thread::hardware_concurrency() - 1);

    double some_func(const size_t N) {
        return some_func_calc(N);
    }
};

// 静态成员初始化
Advisor* Advisor::pinstance_{ nullptr };
std::mutex Advisor::mutex_;

// 获取单例实例
Advisor* Advisor::GetInstance(const size_t nThread) {
    std::lock_guard<std::mutex> lock(mutex_);
    if (pinstance_ == nullptr) {
        pinstance_ = new Advisor(nThread);
    }
    return pinstance_;
}

并行计算函数 #

inline double some_func_calc(const size_t nbPaths) {
    const std::unique_ptr<my_rng> rng_unique_ptr = std::make_unique<sobol>();
    std::vector<double> resultMat(nbPaths);
    // 注：这里代码不完整，原本计划通过线程池拆分循环任务，并行计算后取平均值
    ThreadPool::getInstance()->start(std::thread::hardware_concurrency() - 1);
    // 后续的任务提交和结果汇总逻辑没写完，但当前代码在Intel编译器下已经会触发内存违规
}

补充说明 #

• 我用的concurrent_queue是一个实现了并发安全的队列，支持pop、try_pop、interrupt等操作
• GCC和Clang编译后运行完全正常，但Intel C++ 2025编译后，运行时经常触发内存访问违规，比如读取已释放的内存或者数组越界
• 我怀疑是不是Intel编译器对线程本地存储（TLS）、单例初始化或者内存模型的处理和GCC/Clang有差异，但自己排查不出来具体点

有没有大佬能帮我看看哪里可能出问题？或者给点排查方向也行！

内容来源于stack exchange