[c++]在leetcode中使用线程池加速做题

我随随便便写了个O(N三次方)的代码，但是超时了，怎么办？
一定是平台的问题，嘻嘻嘻🤭🤭🤭🤭
我用上线程池，多开运算，就不会超时啦。
leecode支持C++11以上的语法，正好可以用STL搞多线程。
但是线程开多了也是麻烦事，这里给个线程池的实现。经过测试可以在leecode编译哦。

#define dpool_THREADPOOL_H

#ifdef _WIN32
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#endif // win32
/*
* @file dpool线程池
* @brief 用c++11写的跨平台线程池，支持c++14 c++17语法标准
*       - 使用简单，不易出错。
        - 支持线程复用，提升性能。
        - 支持懒惰创建线程。
        - 必要时自动回收空闲的线程。
* @author senlinzhan  | fgfxf
* @date 2017  | 2023改进
* @note 用chartGPT辅助下增加了对c++17 20版本的支持，增加了一些get set函数
* @note 线程池会自动回收空闲线程，无需从外部主动释放，请放心上船
* @warning 作为合格的开发者，应当保证线程池单例化，因此函数和声明没有分离，
* 如果想要多实例的线程池，请把本hpp文件中的“非模板类成员函数”分离出来即可。
* @warning set方法没有做健壮性检测，作为合格的开发者，相信您不会犯这样的错误。
*
* @see https://github.com/senlinzhan/dpool
*/

#include <condition_variable>
#include <functional>
#include <future>
#include <memory>
#include <mutex>
#include <queue>
#include <thread>
#include <unordered_map>

namespace dpool {

class ThreadPool {
public:
    using MutexGuard = std::lock_guard<std::mutex>;
    using UniqueLock = std::unique_lock<std::mutex>;
    using Thread = std::thread;
    using ThreadID = std::thread::id;
    using Task = std::function<void()>;
    /*
     * @brief dpool初始化，自动获取数量
     * @param 最大线程数自动获取硬件数量
     */
    ThreadPool()
        : ThreadPool(Thread::hardware_concurrency()) // 自动获取cpu硬件线程数
    {}
    /*
     * @brief dpool初始化，指定最大线程数
     * @param 最大线程数
     */
    explicit ThreadPool(size_t maxThreads)
        : quit_(false), currentThreads_(0), idleThreads_(0),
          maxThreads_(maxThreads), WAIT_MINUTES(10), minThreads_(2) {
        if (maxThreads < minThreads_)
            maxThreads = minThreads_; // 最小不小于2
    }

    // disable the copy operations
    /*
     * @brief 禁止拷贝
     */
    ThreadPool(const ThreadPool&) = delete;
    /*
     * @brief 禁止拷贝
     */
    ThreadPool& operator=(const ThreadPool&) = delete;

    /*
     * @brief 析构线程池
     */
    ~ThreadPool() {
        if (!quit_)
            Stop();
    }

    void Stop() {

        {
            MutexGuard guard(mutex_);
            quit_ = true;
        }
        cv_.notify_all(); // 唤醒所有线程

        for (auto& elem : threads_) {
            assert(elem.second.joinable());
            elem.second.join(); // 逐个线程地等待退出
        }
    }

    /*
     * @brief 初始化线程池（非必要）
     *  当创建好线程池对象后，当前工作线程数量为0，调用此函数增加工作线程
     *          非必要操作，适合强迫症程序员
     */
    void Initialize() {
        MutexGuard guard(mutex_);
        if (quit_)
            return;
        while (currentThreads_ < minThreads_) {
            Thread t(&ThreadPool::worker, this);
            assert(threads_.find(t.get_id()) == threads_.end());
            threads_[t.get_id()] = std::move(t); // map线程id---线程 对应
            ++currentThreads_;
        }
    }

    /*
     * @brief dpool提交任务
     * @param func函数
     * @param ...变长参数，func的函数列表
     * @return 利用标准库函数std::future异步获取函数的返回值
     */
    template <typename Func, typename... Ts>
    auto submit(Func&& func, Ts&&... params)
    //  -> std::future<typename std::result_of<Func(Ts...)>::type>
    {
        // 函数参数转发---完美转发
        auto execute =
            std::bind(std::forward<Func>(func), std::forward<Ts>(params)...);
#if (defined(_MSVC_LANG) && _MSVC_LANG > 201402L) || __cplusplus > 201402L
        // 当使用msvc编译器，则_MSVC_LANG。否则gcc/g++ __cplusplus
        // msvc中__cplusplus始终是98年，f**k
        using ReturnType =
            std::invoke_result_t<Func, Ts...>; // 利用编译期运算获取函数返回类型
#else
        using ReturnType = typename std::result_of<Func(Ts...)>::type;
#endif

        using PackagedTask = std::packaged_task<ReturnType()>;
        // 移动execute变成task
        auto task = std::make_shared<PackagedTask>(std::move(execute));
        auto result = task->get_future();

        MutexGuard guard(mutex_);
        assert(!quit_);
        // tasks任务列表添加一个task
        tasks_.emplace([task]() { (*task)(); });
        // 当空闲线程>0,就执行一个
        if (idleThreads_ > 0) {
            cv_.notify_one(); // 唤醒一个线程
        }
        // 创建新的线程
        else if (currentThreads_ < maxThreads_) {
            Thread t(&ThreadPool::worker, this);
            assert(threads_.find(t.get_id()) == threads_.end());
            threads_[t.get_id()] = std::move(t); // map线程id---线程 对应
            ++currentThreads_;
        }

        return result;
    }

    /*
     * @brief 返回当前创建的线程的数量
     * @return size_t线程数量
     */
    size_t getCurrenThreadsNum() const { return currentThreads_; }
    /*
     * @brief 返回当前线程池最大线程数量
     * @return size_t线程数量
     */
    size_t getMaxThreadsNum() { return maxThreads_; }
    /*
     * @brief 设置最大线程数量
     * @param size_t线程数量
     */
    void setMaxThreadsNum(size_t szNewMaxThreadCount) {
        maxThreads_ = szNewMaxThreadCount;
    }

    /*
     * @brief 返回当前线程池最小线程数量
     * @return size_t线程数量
     */
    size_t getMinThreadsNum() { return minThreads_; }
    /*
     * @brief 设置最小线程数量
     * @param size_t线程数量
     */
    void setMinThreadsNum(size_t szNewMinThreadCount) {
        minThreads_ = szNewMinThreadCount;
    }

    /*
     * @brief 获取线程空闲等待销毁时长
     * @param size_t单位：分钟
     */
    size_t getWaitMinutes() { return WAIT_MINUTES; }
    /*
     * @brief 设置线程空闲销毁时长，单位:分钟
     */
    void setWaitMinutes(size_t WaitMinutes) {
        MutexGuard guard(mutex_);
        WAIT_MINUTES = WaitMinutes;
    }

    /*
     * @brief 获取当前任务队列等待分配任务数量
     * @return size_t 任务数量
     */
    size_t getTaskCount() {
        MutexGuard guard(mutex_);
        return tasks_.size();
    }

private:
    /*
     * @brief 工作线程，submit函数提交任务之后，如果没有线程就会创建线程。
     * 子线程执行这里
     */
    void worker() {
        while (!quit_) {
            Task task;
            { // 代码块 加锁
                UniqueLock uniqueLock(mutex_);
                ++idleThreads_;

                // 工作线程休眠：当超时WAIT_MINUTES或者quit__或者任务非空时唤醒。
                bool hasTimedout = !cv_.wait_for(
                    uniqueLock, std::chrono::minutes(WAIT_MINUTES),
                    [this]() { return quit_ || !tasks_.empty(); });
                --idleThreads_;
                // 如果任务列表空了
                if (tasks_.empty()) {
                    if (quit_) // 如果退出
                    {
                        --currentThreads_; // 线程会由析构函数回收，不做处理
                        return;
                    }
                    // 超时销毁线程
                    if (hasTimedout) {
                        DestroyFinishedThreads(); // 清理其他线程
                        if (currentThreads_ > minThreads_) {
                            // 如果线程比较多
                            --currentThreads_;
                            finishedThreadIDs_.emplace(
                                std::this_thread::
                                    get_id()); // 当前线程自己加入到待清理队列
                            return;
                        }
                        continue; // 继续循环
                    }
                }

                // 任务列表不为空时，执行队列函数
                task = std::move(tasks_.front());
                tasks_.pop();
                // 代码解锁
            }
            task();
        }
    }
    /*
     * @brief 清理线程
     * 清理所有加入到finishedThreadIDs_队列的线程
     */
    void DestroyFinishedThreads() {
        // 循环将所有finishedThreadIDs_队列中的线程都释放掉
        // finishedThreadIDs_是完成任务的线程id队列
        while (!finishedThreadIDs_.empty()) {
            ThreadID id = std::move(finishedThreadIDs_.front());
            finishedThreadIDs_.pop();
            auto iter = threads_.find(id);
            assert(iter != threads_.end());
            assert(iter->second.joinable());
            iter->second.join();
            threads_.erase(iter);
        }
    }

    size_t WAIT_MINUTES; // 线程等待销毁，若任务列表空，等待多少时长线程池被优化
    std::atomic<bool> quit_;     // 退出标志
    size_t currentThreads_;      // 当前线程数量
    size_t idleThreads_;         // 空闲线程数量
    size_t maxThreads_;          // 最大线程数量
    size_t minThreads_;          // 最小线程数量，保证突发性
    mutable std::mutex mutex_;   // 互斥体
    std::condition_variable cv_; // 条件变量，用于线程唤醒
    std::queue<Task> tasks_;     // 任务队列
    std::queue<ThreadID> finishedThreadIDs_;       // 完成的线程ID
    std::unordered_map<ThreadID, Thread> threads_; // map   线程id -- 线程
};

} // namespace dpool

#endif /* THREADPOOL_H */

使用案例：
leecode 437

    long long int m_target = 0;
    long long int m_numsOfPathSum = 0;

class Solution {

public:
    dpool::ThreadPool m_pool;
    Solution(){
        m_numsOfPathSum = 0;
    }
    int pathSum(TreeNode* root, int targetSum) {
        if (!root)
            return 0; // 根节点不为空
        m_target = targetSum;
        //DFS(root, 0);
        pathSum2(root,targetSum);
        while(1){
            if(m_pool.getCurrenThreadsNum()==m_pool.getIdleCount())
                break;
                std::this_thread::sleep_for(std::chrono::milliseconds(1)); // 休眠100毫秒
        }
        
        return m_numsOfPathSum;
    }
    int pathSum2(TreeNode* root, int targetSum) {
        if (!root)
            return 0; // 根节点不为空
        //DFS(root, 0);
        m_pool.submit(DFS,root,0);
        //m_pool.submit(pathSum2,root->left,targetSum);
        //m_pool.submit(pathSum2,root->right,targetSum);
        pathSum2(root->left, targetSum);
        pathSum2(root->right, targetSum);
        return m_numsOfPathSum;
    }
    // 传入参数，不带当前节点的链接和
    static void DFS(TreeNode* root,     long long int currentSum) {
        // 带上本节点的路径和
        if ((root->val + currentSum) == m_target)
            m_numsOfPathSum++;
        if (root->left) {
            DFS(root->left,
                (root->val + currentSum)); // 递归左侧，且带上父、自己
            // 递归左侧，不带父节点，从自己开始，带上自己
        }
        if (root->right) {
            DFS(root->right,
                (root->val + currentSum)); // 递归右侧，且带上父、自己
            // 递归右侧，不带父节点，带上自己，从自己开始
        }
    }
};