qt 线程举例

在Qt中，使用线程的一个常见方式是通过QThread类。下面是一个简单的例子，展示了如何创建一个线程并在其中执行任务。

步骤 1: 创建一个Worker类

首先，创建一个继承自QObject的Worker类，这个类将包含要在线程中执行的任务。

// worker.h  
#ifndef WORKER_H  
#define WORKER_H  
  
#include <QObject>  
  
class Worker : public QObject  
{  
    Q_OBJECT  
public:  
    explicit Worker(QObject *parent = nullptr);  
  
signals:  
    void resultReady(const QString &result);  
  
public slots:  
    void doWork(const QString &parameter);  
};  
  
#endif // WORKER_H

cpp复制代码

// worker.cpp  
#include "worker.h"  
  
Worker::Worker(QObject *parent) :  
    QObject(parent)  
{  
}  
  
void Worker::doWork(const QString &parameter) {  
    QString result;  
    // 假设这里是耗时的计算任务  
    result = "Result of " + parameter;  
    emit resultReady(result);  
}

步骤 2: 在主线程中使用Worker

在你的主窗口或主应用中，创建QThread和Worker的实例，并将Worker移动到新线程中。

cpp复制代码

#include <QCoreApplication>  
#include <QThread>  
#include "worker.h"  
  
int main(int argc, char *argv[])  
{  
    QCoreApplication a(argc, argv);  
  
    QThread* thread = new QThread();  
    Worker* worker = new Worker();  
    worker->moveToThread(thread);  
  
    QObject::connect(worker, &Worker::resultReady, [](const QString &result){  
        qDebug() << result;  
    });  
    QObject::connect(thread, &QThread::started, worker, [worker](){  
        worker->doWork("Hello");  
    });  
    QObject::connect(worker, &Worker::finished, thread, &QThread::quit);  
    QObject::connect(worker, &Worker::finished, worker, &Worker::deleteLater);  
    QObject::connect(thread, &QThread::finished, thread, &QThread::deleteLater);  
  
    thread->start();  
  
    return a.exec();  
}

在这个例子中，Worker对象的doWork方法将在新创建的线程中执行。当工作完成时，它会发出resultReady信号，你可以在主线程中连接这个信号以获取结果。

请注意，为了示例的简洁性，我省略了一些错误检查和异常处理，这在实际应用中是非常重要的。

2.补充说明

2.1 QObject::connect(worker, &Worker::finished, thread, &QThread::quit);

在Qt中，QObject::connect函数用于连接信号和槽，以便在某个对象发出信号时，另一个对象的槽函数被调用。然而，你提到的这行代码：

QObject::connect(worker, &Worker::finished, thread, &QThread::quit);

存在一个问题：Worker类并没有内置的finished信号。这行代码看起来是你想在工作完成后让线程退出，但实际上你需要自己定义finished信号，并在适当的时候发出它。

正确的做法应该是在Worker类中定义一个finished信号，然后在工作完成后发出这个信号。例如：

cpp复制代码

// worker.h  
#ifndef WORKER_H  
#define WORKER_H  
  
#include <QObject>  
  
class Worker : public QObject  
{  
    Q_OBJECT  
public:  
    explicit Worker(QObject *parent = nullptr);  
  
signals:  
    void resultReady(const QString &result);  
    void finished(); // 自定义的finished信号  
  
public slots:  
    void doWork(const QString &parameter);  
};  
  
#endif // WORKER_H

然后在doWork方法的末尾发出finished信号：

// worker.cpp  
#include "worker.h"  
  
Worker::Worker(QObject *parent) :  
    QObject(parent)  
{  
}  
  
void Worker::doWork(const QString &parameter) {  
    QString result;  
    // 假设这里是耗时的计算任务  
    result = "Result of " + parameter;  
    emit resultReady(result);  
    emit finished(); // 发出finished信号  
}

现在，你可以在你的主函数或其他适当的地方连接finished信号到QThread::quit槽，以便在工作完成后让线程退出：

QObject::connect(worker, &Worker::finished, thread, &QThread::quit);

这样，当Worker对象的工作完成后，它会发出finished信号，这个信号会被连接到QThread的quit槽上，从而导致线程退出。

2.2 qt线程的其他示例是什么

Qt线程的其他示例主要可以归纳为以下几种方式：

1. 继承QThread，重写run()方法

这是最基本的Qt线程使用方式。通过创建一个继承自QThread的类，并重写其run()方法，可以在该方法中执行耗时操作。然后，通过调用start()方法启动线程，run()方法将自动在新线程中执行。

示例代码：

class MyThread : public QThread  
{  
    Q_OBJECT  
public:  
    void run() override {  
        // 在这里执行耗时操作  
        for (int i = 0; i < 10; ++i) {  
            qDebug() << "线程运行中：" << i;  
            QThread::sleep(1); // 模拟耗时操作  
        }  
    }  
};  
  
// 在主函数或其他地方使用  
MyThread *thread = new MyThread();  
thread->start(); // 启动线程  
// 等待线程结束（可选）  
thread->wait();  
delete thread; // 清理资源

2. 使用QObject的moveToThread方法

官方推荐的方法之一。通过创建一个继承自QObject的Worker类，并将其实例移动到QThread管理的线程中执行。这种方式比直接继承QThread更灵活，因为它允许将线程逻辑与线程管理分离。

示例代码（已在之前的回答中给出部分，这里补充完整）：

Worker类和主函数使用示例已在之前的回答中详细说明，不再重复。

3. 使用QThreadPool进行线程池操作

QThreadPool用于管理和回收单个QThread对象，以减少线程创建和销毁的开销。通过QThreadPool::globalInstance()可以访问全局的线程池实例，并使用start(QRunnable *runnable)方法提交任务。

示例代码：

class MyTask : public QRunnable  
{  
public:  
    void run() override {  
        // 执行任务  
        qDebug() << "线程池任务执行中：" << QThread::currentThread();  
    }  
};  
  
// 在主函数或其他地方使用  
MyTask *task = new MyTask();  
QThreadPool::globalInstance()->start(task);  
// 注意：默认情况下，QThreadPool会自动删除传入的QRunnable对象

4. 使用QtConcurrent模块

QtConcurrent模块提供了更高级的API，允许在不直接使用低级线程原语（如互斥锁、读写锁、等待条件或信号量）的情况下编写多线程程序。它会自动根据可用的处理器核心数调整使用的线程数。

示例代码（使用QtConcurrent::run）：

#include <QtConcurrent>  
  
void myFunction(int parameter) {  
    // 耗时操作  
    qDebug() << "QtConcurrent任务执行中，参数为：" << parameter;  
}  
  
// 在主函数或其他地方使用  
QtConcurrent::run(myFunction, 42); // 异步执行myFunction，参数为42

QtConcurrent还提供了其他功能，如mapped、mappedReduced、filtered等，用于对容器中的元素进行并行处理。

综上所述，Qt提供了多种灵活的方式来使用线程，开发者可以根据具体需求选择最适合的方法。

2.3 qt 线程间的通讯方式就是信号和槽，对吗

Qt 线程间的通讯方式不仅仅是信号和槽。虽然信号和槽是 Qt 中非常重要的一种通信机制，特别是在 GUI 编程中，它们用于对象之间的通信，包括不同线程之间的对象。但是，在多线程编程中，Qt 也提供了其他机制来实现线程间的通信和同步。

除了信号和槽，Qt 线程间的通讯还可以通过以下方式实现：

直接使用互斥锁（QMutex）：
互斥锁可以用来保护共享数据，防止多个线程同时访问造成数据竞争。
读写锁（QReadWriteLock）：
读写锁允许多个线程同时读取共享数据，但写入时需要独占访问。
等待条件（QWaitCondition）：
等待条件用于线程间的同步，一个线程可以在某个条件变量上等待，而另一个线程在条件满足时通知等待的线程。
信号量（QSemaphore）：
信号量用于控制对共享资源的访问数量，它可以允许多个线程同时访问一定数量的共享资源。
原子操作（QAtomicInt, QAtomicPointer 等）：
原子操作提供了在多线程环境中安全执行简单操作的方法，如自增、自减、赋值等。
事件（QEvent）：
虽然事件主要用于 Qt 的事件系统，但也可以用于线程间的通信，特别是通过自定义事件。
直接调用线程安全的方法或函数：
如果某个方法或函数是线程安全的，那么可以在多个线程中直接调用它，而不需要额外的同步机制。
使用 QtConcurrent 模块：
QtConcurrent 提供了高级的多线程编程接口，包括异步执行任务、并行映射和过滤等，这些都可以用于线程间的通信和同步。

因此，虽然信号和槽是 Qt 中非常重要的通信机制，但在多线程编程中，Qt 提供了多种机制来实现线程间的通信和同步。开发者可以根据具体需求选择最适合的方法。

2.4线程暂停

线程暂停（Thread Suspension）是线程管理中的一个概念，指的是使线程暂时停止执行，并在满足特定条件后恢复执行的过程。在多线程编程中，有时需要暂停某个线程的执行，以便等待某些资源或条件满足后再继续执行。

实现线程暂停的方法

使用标志位：
- 线程运行时，检查一个标志位。
- 若标志位指示暂停，则线程进入等待状态（如使用 while 循环检查）。
- 当外部条件改变标志位时，线程继续执行。
使用 wait() 和 notify() 方法：
- 线程调用 wait() 进入等待状态。
- 另一个线程调用 notify() 或 notifyAll() 唤醒等待的线程。
使用 Lock 和 Condition：
- Lock 对象提供一个或多个 Condition 对象。
- 线程调用 Condition 的 await() 方法暂停执行。
- 另一个线程调用 signal() 或 signalAll() 方法唤醒等待的线程。
使用 Thread.sleep()：
- 线程调用 sleep() 方法进入休眠状态，暂停执行指定的毫秒数。
- 休眠结束后，线程自动唤醒并继续执行。
使用 TimeUnit 类：
- TimeUnit 类提供了 sleep() 方法的替代，允许指定时间单位。
- 线程调用 TimeUnit.SECONDS.sleep(1) 等方法暂停执行。

注意事项

暂停线程应谨慎使用，因为它可能导致死锁或资源竞争问题。
在设计多线程程序时，应尽量避免不必要的线程暂停，以提高程序的响应性和性能。
使用 wait() 和 notify() 方法时，必须在同步代码块或同步方法中进行，因为它们依赖于对象的监视器锁。

2.5 qt 线程休眠

在Qt中，如果你想要让线程休眠一段时间，可以使用QThread类的静态方法sleep()，或者使用QTimer来达到休眠的效果。不过，更常见的是使用QThread::sleep()，因为它简单易用。

以下是一个使用QThread::sleep()让线程休眠的例子：

#include <QThread>  
#include <QDebug>  
  
void myFunction() {  
    qDebug() << "线程开始执行";  
  
    // 休眠2秒  
    QThread::sleep(2);  
  
    qDebug() << "线程休眠结束，继续执行";  
}  
  
int main(int argc, char *argv[]) {  
    QCoreApplication a(argc, argv);  
  
    // 在主线程中调用myFunction，该函数中的线程会休眠2秒  
    myFunction();  
  
    return a.exec();  
}

在这个例子中，myFunction函数中的线程会打印一条消息，然后休眠2秒，最后再次打印一条消息表示休眠结束。

需要注意的是，QThread::sleep()是一个静态方法，它会使当前线程休眠，而不是某个特定的QThread对象。因此，你可以在任何地方调用它，包括在主线程或其他工作线程中。

另外，虽然QThread::sleep()很方便，但在设计多线程程序时，过度依赖线程休眠可能会导致性能问题或死锁等并发问题。因此，在使用线程休眠时，请确保你了解其对程序行为的影响。

2.6 qt 在子线程中创建udp 服务端

在Qt中，要在子线程中创建一个UDP服务端，你需要做几件事情：

创建一个继承自QThread的类，在这个类中实现UDP服务器的功能。
在这个类中，使用QUdpSocket来监听和接收UDP数据包。
启动这个线程，并在其中初始化UDP服务器。

下面是一个简单的例子，展示了如何在子线程中创建一个UDP服务端：

#include <QCoreApplication>  
#include <QThread>  
#include <QUdpSocket>  
#include <QDebug>  
  
class UdpServerThread : public QThread {  
    Q_OBJECT  
  
public:  
    UdpServerThread(QObject *parent = nullptr) : QThread(parent), udpSocket(new QUdpSocket(this)) {  
        connect(udpSocket, &QUdpSocket::readyRead, this, &UdpServerThread::readPendingDatagrams);  
    }  
  
    ~UdpServerThread() {  
        udpSocket->close();  
        udpSocket->deleteLater();  
    }  
  
protected:  
    void run() override {  
        // 绑定到特定的端口  
        udpSocket->bind(QHostAddress::Any, 12345);  
  
        exec(); // 进入事件循环  
    }  
  
private slots:  
    void readPendingDatagrams() {  
        while (udpSocket->hasPendingDatagrams()) {  
            QByteArray datagram;  
            datagram.resize(int(udpSocket->pendingDatagramSize()));  
            udpSocket->readDatagram(datagram.data(), datagram.size());  
  
            // 处理接收到的数据  
            qDebug() << "Received:" << datagram;  
        }  
    }  
  
private:  
    QUdpSocket *udpSocket;  
};  
  
int main(int argc, char *argv[]) {  
    QCoreApplication a(argc, argv);  
  
    UdpServerThread udpServer;  
    udpServer.start(); // 启动线程  
  
    return a.exec();  
}  
  
#include "main.moc"

在这个例子中，UdpServerThread类继承自QThread，并在其run方法中初始化了QUdpSocket，然后绑定到端口12345上。当UDP数据包到达时，readPendingDatagrams槽函数会被调用，用于读取和处理数据。

请注意，你需要在你的项目文件（比如.pro文件）中添加QT += network来确保Qt网络模块被正确包含。