帮我写一个 qt 5.15.2 线程池任务队列

好的，我可以回答这个问题。以下是一个简单的 Qt 5.15.2 线程池任务队列的实现：

首先，我们需要定义一个任务类，它包含一个执行任务的函数：

class Task {
public:
    virtual void run() = 0;
};

然后，我们定义一个任务队列类，它包含一个任务队列和一个线程池：

class TaskQueue {
public:
    TaskQueue(int threadCount) {
        for (int i = 0; i < threadCount; ++i) {
            QThread* thread = new QThread(this);
            thread->start();
            m_threads.append(thread);
        }
    }

    ~TaskQueue() {
        for (int i = 0; i < m_threads.size(); ++i) {
            m_threads[i]->quit();
            m_threads[i]->wait();
        }
    }

    void addTask(Task* task) {
        m_mutex.lock();
        m_tasks.append(task);
        m_mutex.unlock();
        m_semaphore.release();
    }

private:
    QList<QThread*> m_threads;
    QList<Task*> m_tasks;
    QMutex m_mutex;
    QSemaphore m_semaphore;
};

在任务队列类中，我们使用一个信号量来控制线程池中的线程数量。当有新任务添加到任务队列中时，我们会释放一个信号量，让一个线程来执行任务。

最后，我们定义一个任务执行器类，它会从任务队列中取出任务并执行：

class TaskExecutor : public QObject {
    Q_OBJECT
public:
    TaskExecutor(TaskQueue* taskQueue) : m_taskQueue(taskQueue) {
        connect(taskQueue, &TaskQueue::taskAdded, this, &TaskExecutor::onTaskAdded);
    }

private slots:
    void onTaskAdded() {
        while (true) {
            m_taskQueue->m_semaphore.acquire();
            m_taskQueue->m_mutex.lock();
            if (m_taskQueue->m_tasks.isEmpty()) {
                m_taskQueue->m_mutex.unlock();
                continue;
            }
            Task* task = m_taskQueue->m_tasks.takeFirst();
            m_taskQueue->m_mutex.unlock();
            task->run();
            delete task;
        }
    }

private:
    TaskQueue* m_taskQueue;
};

在任务执行器类中，我们使用一个死循环来不断地从任务队列中取出任务并执行。

最后，我们可以使用以下代码来创建一个线程池任务队列：

TaskQueue taskQueue(4);
TaskExecutor taskExecutor(&taskQueue);

for (int i = 0; i < 10; ++i) {
    taskQueue.addTask(new MyTask(i));
}

其中，`MyTask` 是我们自己定义的任务类，它继承自 `Task` 并实现了 `run` 函数。