qt多个线程操作同一个队列，举例

假设你有一个任务队列，需要多个线程来处理队列中的任务，可以使用 Qt 的信号槽机制来实现。

首先定义一个任务类，例如：

class Task : public QObject
{
    Q_OBJECT
public:
    explicit Task(QObject *parent = nullptr) : QObject(parent) {}
    virtual ~Task() {}

    // 执行任务的函数
    virtual void run() = 0;

signals:
    // 任务完成信号，用于通知队列有任务已经完成
    void finished();
};

然后定义一个任务队列类，例如：

class TaskQueue : public QObject
{
    Q_OBJECT
public:
    explicit TaskQueue(QObject *parent = nullptr) : QObject(parent) {}

    // 添加任务到队列
    void addTask(Task *task)
    {
        m_tasks.enqueue(task);
        emit taskAdded();
    }

    // 获取队列中的下一个任务
    Task *getNextTask()
    {
        if (m_tasks.isEmpty()) {
            return nullptr;
        }
        return m_tasks.dequeue();
    }

signals:
    // 有任务添加到队列信号，通知等待任务的线程可以取任务了
    void taskAdded();

private:
    QQueue<Task*> m_tasks;
};

在主线程中创建任务队列和多个工作线程，并将它们连接起来：

TaskQueue taskQueue;

QThread thread1;
Worker worker1;
worker1.moveToThread(&thread1);
QObject::connect(&thread1, &QThread::started, &worker1, &Worker::processTasks);
QObject::connect(&taskQueue, &TaskQueue::taskAdded, &worker1, &Worker::wakeUp);

QThread thread2;
Worker worker2;
worker2.moveToThread(&thread2);
QObject::connect(&thread2, &QThread::started, &worker2, &Worker::processTasks);
QObject::connect(&taskQueue, &TaskQueue::taskAdded, &worker2, &Worker::wakeUp);

thread1.start();
thread2.start();

其中 `Worker` 类是处理任务的工作线程类，例如：

class Worker : public QObject
{
    Q_OBJECT
public:
    explicit Worker(QObject *parent = nullptr) : QObject(parent) {}

    // 处理任务的函数
    void processTasks()
    {
        while (true) {
            QMutexLocker locker(&m_mutex);
            m_waitCondition.wait(&m_mutex);
            Task *task = m_taskQueue.getNextTask();
            if (task != nullptr) {
                locker.unlock();
                task->run();
                emit task->finished();
            }
        }
    }

public slots:
    // 唤醒工作线程的槽函数
    void wakeUp()
    {
        m_waitCondition.wakeAll();
    }

private:
    QMutex m_mutex;
    QWaitCondition m_waitCondition;
    TaskQueue m_taskQueue;
};

在 `Worker` 类中，通过互斥锁和条件变量来等待任务队列中的任务。当有新的任务添加到队列中时，通过 `wakeUp` 槽函数来唤醒等待任务的线程，从而取出任务并执行。执行完成后通过信号来通知主线程任务已经完成。

这样就可以在多个线程中安全地操作同一个任务队列了。