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
相关产品推荐
相关产品推荐

