使用QThreadPool/QRunnable时如何合理分配任务？

你原来用std::thread的方案是按线程ID静态拆分任务，每个线程处理threadID, threadID+numThreads, ...索引的任务，但QThreadPool确实不推荐依赖线程ID来做业务逻辑。这里提供两种等价的实现思路，既保证任务无重复不遗漏，又不会阻塞主线程：

方法1：预分配任务子集给每个QRunnable #

直接把任务列表按线程数拆分成多个子集，每个QRunnable负责处理固定的一段任务，完全不需要依赖线程ID。

自定义QRunnable子类 #

class TaskRunnable : public QRunnable
{
public:
    // 构造时传入要处理的起始索引、步长和任务列表
    TaskRunnable(myClass* handler, size_t startIdx, size_t step, const std::vector<Task>& tasks)
        : m_handler(handler), m_startIdx(startIdx), m_step(step), m_tasks(tasks) {}

    void run() override {
        // 和原runThread逻辑完全一致，处理对应索引的任务
        for (size_t i = m_startIdx; i < m_tasks.size(); i += m_step) {
            m_handler->processSingleTask(i); // 替换成你的任务执行逻辑
        }
    }

private:
    myClass* m_handler;
    size_t m_startIdx;
    size_t m_step;
    const std::vector<Task>& m_tasks;
};

提交任务到线程池 #

void myClass::startTaskProcessing() {
    unsigned int threadCount = QThread::idealThreadCount();
    QThreadPool* threadPool = QThreadPool::globalInstance();
    threadPool->setMaxThreadCount(threadCount);

    if (threadCount == 1) {
        // 单线程场景直接执行，或者也可以提交到线程池
        processSingleTaskLoop(0, 1);
    } else {
        for (unsigned int i = 0; i < threadCount; ++i) {
            TaskRunnable* runnable = new TaskRunnable(this, i, threadCount, m_tasks);
            runnable->setAutoDelete(true); // 让线程池自动回收对象
            threadPool->start(runnable);
        }
    }

    // 监听线程池完成信号，在回调里更新GUI（绝对不要在主线程调用waitForDone）
    connect(threadPool, &QThreadPool::finished, this, &myClass::onAllTasksCompleted);
}

方法2：用原子计数器动态分配任务 #

如果任务耗时不均匀，静态拆分可能导致部分线程早早完成、部分线程长期忙碌。这种情况下可以用原子变量作为全局任务索引，每个线程主动取未处理的任务，直到所有任务完成。

动态分配的QRunnable子类 #

class DynamicTaskRunnable : public QRunnable
{
public:
    DynamicTaskRunnable(myClass* handler, std::atomic<size_t>& taskIdx, const std::vector<Task>& tasks)
        : m_handler(handler), m_taskIdx(taskIdx), m_tasks(tasks) {}

    void run() override {
        size_t currentIdx;
        // 原子操作获取下一个未处理的任务索引，直到所有任务都被处理
        while ((currentIdx = m_taskIdx.fetch_add(1)) < m_tasks.size()) {
            m_handler->processSingleTask(currentIdx);
        }
    }

private:
    myClass* m_handler;
    std::atomic<size_t>& m_taskIdx;
    const std::vector<Task>& m_tasks;
};

提交动态任务 #

void myClass::startDynamicTaskProcessing() {
    unsigned int threadCount = QThread::idealThreadCount();
    QThreadPool* threadPool = QThreadPool::globalInstance();
    threadPool->setMaxThreadCount(threadCount);

    std::atomic<size_t> currentTaskIdx(0);
    for (unsigned int i = 0; i < threadCount; ++i) {
        DynamicTaskRunnable* runnable = new DynamicTaskRunnable(this, currentTaskIdx, m_tasks);
        runnable->setAutoDelete(true);
        threadPool->start(runnable);
    }

    connect(threadPool, &QThreadPool::finished, this, &myClass::onAllTasksCompleted);
}

关键注意事项 #

• 绝对不要在主线程调用QThreadPool::waitForDone()，否则会像原来的std::thread::join()一样阻塞GUI渲染，必须用信号槽监听任务完成事件。
• 如果任务需要修改共享数据，要注意加锁（比如用QMutex）或者使用原子操作，避免线程冲突。

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