写一个qt的多线程例子

### 回答1：

以下是一个使用 Qt 创建多线程应用程序的简单例子：#include <QtCore>class Worker : public QObject
{
Q_OBJECTpublic slots:
void doWork()
{
QString result;
/* ... here is the expensive or blocking operation ... */
emit resultReady(result);
}signals:
void resultReady(const QString &s);
};int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv); Worker *worker = new Worker;
QThread *thread = new QThread;
worker->moveToThread(thread);
thread->start(); QObject::connect(worker, &Worker::resultReady,
[](const QString &s){ qDebug() << s; });
QMetaObject::invokeMethod(worker, "doWork", Qt::QueuedConnection); return a.exec();
}

### 回答2：
下面是一个简单的Qt多线程的例子：

#include <QtWidgets>
#include <QtCore>

// 继承自 QObject 并且 Q_OBJECT 宏
class WorkerThread : public QObject
{
    Q_OBJECT

public:
    explicit WorkerThread(QObject *parent = nullptr) : QObject(parent) {}

public slots:
    // 在新线程中执行的耗时操作
    void doWork()
    {
        // 模拟耗时操作
        for (int i = 0; i < 1000000000; ++i) {}

        // 发射信号，通知主线程操作完成
        emit workDone();
    }

signals:
    // 信号，通知主线程操作完成
    void workDone();
};

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    // 创建一个新的线程
    QThread workerThread;

    // 创建一个 WorkerThread 的对象
    WorkerThread worker;

    // 将 WorkerThread 对象移动到新线程中
    worker.moveToThread(&workerThread);

    // 连接信号和槽，当 WorkerThread 发射 workDone 信号时，调用主线程的槽函数
    QObject::connect(&worker, SIGNAL(workDone()), qApp, SLOT(quit()), Qt::QueuedConnection);

    // 当新线程启动时，调用 worker 的 doWork 槽函数
    QObject::connect(&workerThread, SIGNAL(started()), &worker, SLOT(doWork()));

    // 当线程完成工作后，退出线程事件循环
    QObject::connect(&worker, SIGNAL(workDone()), &workerThread, SLOT(quit()));

    // 通过调用 QThread::start，启动新线程，并进入事件循环
    workerThread.start();

    return app.exec();
}

上面的例子中，我们创建了一个名为 WorkerThread 的类，继承自 QObject，并使用 Q_OBJECT 宏进行声明，以便使用 Qt 的信号和槽机制。WorkerThread 类中定义了一个 doWork() 槽函数，用来模拟一个耗时操作。当耗时操作完成后，通过发射 workDone 信号，通知主线程操作完成。

在主函数中，我们创建了一个新的线程 workerThread，然后创建一个 WorkerThread 对象 worker，并将其移动到 workerThread 线程中。然后我们通过连接信号和槽，将 workerThread 中的 started 信号与 worker 的 doWork 槽函数连接起来，以便在线程启动时调用 doWork()。还将 workerThread 中的 finished 信号与 workerThread 的 quit 槽函数连接，以便在线程完成工作后退出线程事件循环。

最后通过调用 workerThread.start() 启动线程，并运行 app.exec() 进入主线程的事件循环。当 worker 发射 workDone 信号时，会调用主线程的 quit() 槽函数退出事件循环，程序结束运行。

### 回答3：
下面是一个使用Qt框架实现的一个简单的多线程例子：

#include <QCoreApplication>
#include <QThread>
#include <QDebug>

// 子线程类
class WorkerThread : public QThread
{
public:
    void run() override
    {
        qDebug() << "子线程开始执行";

        // 模拟耗时操作
        for (int i = 0; i < 5; i++) {
            // 每次休眠1秒
            sleep(1);
            qDebug() << "子线程执行中...";
        }

        qDebug() << "子线程执行完成";
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    qDebug() << "主线程开始执行";

    // 创建子线程对象
    WorkerThread worker;
    // 启动子线程
    worker.start();

    // 模拟主线程执行其他任务
    for (int i = 0; i < 3; i++) {
        // 每次休眠1秒
        sleep(1);
        qDebug() << "主线程执行中...";
    }

    qDebug() << "主线程执行完成";

    // 等待子线程执行完毕
    worker.wait();

    return a.exec();
}

这个例子创建了一个继承自QThread的子线程类WorkerThread，重写了run方法，在run方法中模拟了一个耗时操作。在主函数main中，首先创建了一个WorkerThread对象，并调用start方法启动子线程。然后主线程执行其他任务，最后使用wait方法等待子线程执行完毕。运行程序，可以观察到主线程和子线程的执行顺序和交替执行的效果。