exam_timer_teacher/api/requestthreadpool.cpp

#include "requestthreadpool.h"
#include <QTimer>
#include <QDebug>

namespace TC {

RequestThreadPool* RequestThreadPool::s_instance = nullptr;

RequestThreadPool* RequestThreadPool::instance()
{
    if (!s_instance) {
        s_instance = new RequestThreadPool();
    }
    return s_instance;
}

RequestThreadPool::RequestThreadPool(QObject* parent)
    : QObject(parent)
{
    // 默认设置为4个线程
    m_threadPool.setMaxThreadCount(4);
}

RequestThreadPool::~RequestThreadPool()
{
    m_threadPool.waitForDone();
}

void RequestThreadPool::setMaxThreadCount(int count)
{
    m_threadPool.setMaxThreadCount(count);
}

int RequestThreadPool::activeThreadCount() const
{
    return m_threadPool.activeThreadCount();
}

void RequestThreadPool::addTask(std::shared_ptr<RequestTask> task)
{
    if (!task) {
        return;
    }
    
    // 连接信号槽，传递任务指针作为参数
    connect(task.get(), &RequestTask::taskCompleted, this, &RequestThreadPool::onTaskCompleted);
    connect(task.get(), &RequestTask::taskFailed, this, [this, task]() {
        this->onTaskFailed(task.get());
    });
    
    QMutexLocker locker(&m_mutex);
    m_taskQueue.enqueue(task);
    
    // 如果线程池有空闲线程，则立即处理任务
    if (m_threadPool.activeThreadCount() < m_threadPool.maxThreadCount()) {
        std::shared_ptr<RequestTask> nextTask = nullptr;
        if (!m_taskQueue.isEmpty()) {
            nextTask = m_taskQueue.dequeue();
            m_activeTaskCount++;
        }
        
        // 在锁释放后启动任务，避免死锁
        if (nextTask) {
            m_threadPool.start(nextTask.get());
        }
    }
}

void RequestThreadPool::processNextTask()
{
    std::shared_ptr<RequestTask> nextTask = nullptr;
    
    {
        QMutexLocker locker(&m_mutex);
        if (!m_taskQueue.isEmpty()) {
            nextTask = m_taskQueue.dequeue();
            m_activeTaskCount++;
        }
    }
    
    // 在锁释放后启动任务，避免死锁
    if (nextTask) {
        m_threadPool.start(nextTask.get());
    }
}

void RequestThreadPool::onTaskCompleted(bool success)
{
    {
        QMutexLocker locker(&m_mutex);
        m_activeTaskCount--;
    }
    
    // 在锁释放后处理下一个任务
    processNextTask();
}

// 修改方法签名，直接接收任务指针作为参数
void RequestThreadPool::onTaskFailed(RequestTask* task)
{
    if (!task) {
        return;
    }
    
    bool canRetry = false;
    int retryCount = 0;
    
    {
        QMutexLocker locker(&m_mutex);
        m_activeTaskCount--;
        
        // 在锁内检查是否可以重试，但不执行重试操作
        canRetry = task->canRetry();
        if (canRetry) {
            task->incrementRetryCount();
            retryCount = task->retryCount();
        }
    }
    
    if (canRetry) {
        qDebug() << "Task failed, retrying..." << retryCount << "of" << task->maxRetries();
        
        // 延迟一段时间后重试 (500ms * 重试次数)
        QTimer::singleShot(500 * retryCount, [this, task]() {
            bool shouldRetry = task->retry();
            
            if (shouldRetry) {
                // 重新加入队列
                bool startTask = false;
                {
                    QMutexLocker locker(&m_mutex);
                    m_activeTaskCount++;
                    startTask = true;
                }
                
                if (startTask) {
                    m_threadPool.start(task);
                }
            } else {
                // 重试失败，处理下一个任务
                processNextTask();
            }
        });
    } else {
        // 达到最大重试次数，处理下一个任务
        processNextTask();
    }
}

} // namespace TC