C++跨平台多线程复用需求：实现类似WaitForAny的线程等待逻辑

核心思路 #

不要手动管理线程的创建与销毁，采用固定大小线程池的思路：提前启动N个线程，每个线程从任务队列中循环获取文件处理，直到所有任务完成。这种方式天然实现线程复用，且完全跨平台。

实现方式（C++11及以上） #

1. 标准库线程+队列+同步原语实现（基础方案） #

纯标准库实现，无需第三方依赖：

#include <iostream>
#include <vector>
#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <string>

// 任务队列与同步对象
std::queue<std::string> file_task_queue;
std::mutex queue_mtx;
std::condition_variable cv;
bool is_all_tasks_done = false;

// 线程工作函数
void thread_worker() {
    while (true) {
        std::string filename;
        {
            std::unique_lock<std::mutex> lock(queue_mtx);
            // 等待任务或结束信号
            cv.wait(lock, []{ return is_all_tasks_done || !file_task_queue.empty(); });

            // 无任务且收到结束信号，退出线程
            if (is_all_tasks_done && file_task_queue.empty()) {
                break;
            }

            filename = file_task_queue.front();
            file_task_queue.pop();
        }

        // 调用外部程序处理文件，示例用system，实际可替换为exec/CreateProcess等高效方式
        std::string cmd = "your_executeable " + filename;
        system(cmd.c_str());
    }
}

int main() {
    const int max_threads = 4; // 你设定的N值
    std::vector<std::string> file_list = {"file1.txt", "file2.txt", "file3.txt", "..."}; // 你的文件列表

    // 填充任务队列
    {
        std::lock_guard<std::mutex> lock(queue_mtx);
        for (const auto& file : file_list) {
            file_task_queue.push(file);
        }
    }
    cv.notify_all(); // 唤醒所有线程开始工作

    // 创建线程池
    std::vector<std::thread> thread_pool;
    for (int i = 0; i < max_threads; ++i) {
        thread_pool.emplace_back(thread_worker);
    }

    // 标记任务全部下发，等待线程处理完剩余任务
    {
        std::lock_guard<std::mutex> lock(queue_mtx);
        is_all_tasks_done = true;
    }
    cv.notify_all();

    // 等待所有线程退出
    for (auto& t : thread_pool) {
        t.join();
    }

    return 0;
}

2. 用std::future/std::async实现（简洁方案） #

无需手动维护线程池，借助异步任务自动管理线程：

#include <iostream>
#include <vector>
#include <future>
#include <string>
#include <algorithm>
#include <chrono>

// 文件处理函数
void process_file(const std::string& filename) {
    std::string cmd = "your_executeable " + filename;
    system(cmd.c_str());
}

int main() {
    const int max_threads = 4;
    std::vector<std::string> file_list = {"file1.txt", "file2.txt", "..."};
    size_t current_file_idx = 0;

    // 启动第一批异步任务
    std::vector<std::future<void>> running_tasks;
    for (int i = 0; i < max_threads && current_file_idx < file_list.size(); ++i) {
        running_tasks.emplace_back(std::async(std::launch::async, process_file, file_list[current_file_idx++]));
    }

    // 循环等待任意任务完成，复用位置启动新任务
    while (current_file_idx < file_list.size()) {
        // 查找已完成的任务
        auto completed_task = std::find_if(running_tasks.begin(), running_tasks.end(),
            [](std::future<void>& task) {
                return task.wait_for(std::chrono::milliseconds(10)) == std::future_status::ready;
            });

        if (completed_task != running_tasks.end()) {
            // 复用该任务位置，启动新的文件处理任务
            *completed_task = std::async(std::launch::async, process_file, file_list[current_file_idx++]);
        }
    }

    // 等待剩余所有任务完成
    for (auto& task : running_tasks) {
        task.get();
    }

    return 0;
}

注意事项 #

• 调用外部程序时，system()简单但效率有限，Linux/macOS推荐用posix_spawn，Windows推荐用CreateProcess，可封装为跨平台函数提升性能。
• 线程池方案适合大量任务场景，性能更稳定；future方案代码更简洁，适合快速实现。
• 所有涉及共享队列的操作必须用互斥锁同步，避免数据竞争。

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