You need to enable JavaScript to run this app. C++如何维持固定并发线程数实现多子问题高效并行求解
优惠活动
大模型
产品
解决方案
定价
更多

C++如何维持固定并发线程数实现多子问题高效并行求解

C++固定并发数动态调度任务实现方案

你遇到的批次化并行短板问题,用固定大小线程池即可解决,核心是让8个工作线程常驻,所有待求解的子问题存入线程安全的任务队列,线程执行完当前任务后自动从队列拉取下一个任务,直到所有任务处理完成,全程保持8个线程满负载运行,不会出现整批等待最慢任务的算力浪费。


实现注意事项

  • 线程安全保护:全局最优解best、best_cost以及控制台打印操作属于多线程共享资源,需要加std::mutex互斥访问,避免数据竞争和输出乱序
  • 求解器隔离:如果你的solver实例不是线程安全的,需要为每个任务单独创建solver副本,或者每个工作线程持有独立的solver实例,避免多线程修改同一个solver的内部状态导致异常
  • 任务无依赖:你的1万个子问题本身是独立的,完全符合线程池的任务调度要求,不需要额外处理任务间依赖

完整代码实现

通用线程池实现(C++11及以上版本可用)

#include <vector>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <future>
#include <climits>

class ThreadPool {
public:
    ThreadPool(size_t threads) : stop(false) {
        for(size_t i = 0;i<threads;++i)
            workers.emplace_back(
                [this] {
                    for(;;) {
                        std::function<void()> task;
                        {
                            std::unique_lock<std::mutex> lock(this->queue_mutex);
                            this->condition.wait(lock,
                                [this]{ return this->stop || !this->tasks.empty(); });
                            if(this->stop && this->tasks.empty())
                                return;
                            task = std::move(this->tasks.front());
                            this->tasks.pop();
                        }
                        task();
                    }
                }
            );
    }

    template<class F, class... Args>
    auto enqueue(F&& f, Args&&... args) 
        -> std::future<typename std::result_of<F(Args...)>::type> {
        using return_type = typename std::result_of<F(Args...)>::type;

        auto task = std::make_shared< std::packaged_task<return_type()> >(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        );
        
        std::future<return_type> res = task->get_future();
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            if(stop)
                throw std::runtime_error("enqueue on stopped ThreadPool");
            tasks.emplace([task](){ (*task)(); });
        }
        condition.notify_one();
        return res;
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();
        for(std::thread &worker: workers)
            worker.join();
    }

private:
    std::vector< std::thread > workers;
    std::queue< std::function<void()> > tasks;
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
};

改造后的业务逻辑

// 你的原有类型定义保持不变,此处仅为适配示例
// struct Solution { int cost; /* 其他原有属性 */ };
// class Solver { /* 原有实现 */ public: int moves; Solution solve(Problem*) const; };

Solution parallel_solve(int n, const std::vector<MoveType>& sols, const Solver& base_solver, const Problem* s) {
    Solution best;
    int best_cost = INT_MAX;
    std::mutex best_mutex;
    std::mutex print_mutex;

    // 初始化8线程的固定大小线程池
    ThreadPool pool(8);
    std::vector<std::future<void>> task_futures;

    for (int i = 0; i < n; i++) {
        // 每个任务捕获独立副本,避免共享变量竞争
        auto task = [i, &sols, base_solver, s, &best, &best_cost, &best_mutex, &print_mutex]() {
            // 每个任务使用独立的solver副本,避免多线程冲突
            Solver solver = base_solver;
            solver.moves = sols[i];
            Solution cur_sol = solver.solve(s->clone());

            // 控制台打印加锁,避免输出乱序
            {
                std::lock_guard<std::mutex> lock(print_mutex);
                std::cout << "Solution " << i << " had a best possible solve of cost " << cur_sol.cost << std::endl;
            }

            // 更新全局最优解加锁,避免数据竞争
            {
                std::lock_guard<std::mutex> lock(best_mutex);
                if (cur_sol.cost < best_cost) {
                    best = cur_sol;
                    best_cost = cur_sol.cost;
                }
            }
        };
        // 提交任务到线程池,存入future等待执行完成
        task_futures.emplace_back(pool.enqueue(task));
    }

    // 阻塞等待所有子任务执行完成
    for (auto& fut : task_futures) {
        fut.get();
    }

    return best;
}

可选优化

如果solver实例的拷贝开销较高,可以用thread_local关键字为每个工作线程创建唯一的solver实例,每个任务复用线程本地的solver修改moves属性即可,进一步降低任务调度开销。

内容的提问来源于stack exchange,提问作者Dugongue

相关产品推荐
方舟 Agent Plan

超全模态模型 × Harness 升级,最新支持 Deepseek-V4.1-Flash、GLM-5.3 系列、Doubao-Seedream-5.0-pro、Kimi-K3 (部分), 限时 9.9 元起

最近更新时间:2026.10.15 17:15:07