C/C++ Qt QThread线程组件的具体使用

在Qt框架中，QThread是一个强大的多线程组件，可以帮助我们轻松地实现线程操作。本文将详细讲解QThread线程组件的具体使用。

基本概念

QThread是Qt中用于线程编程的类，它封装了线程相关的基本操作，如线程的创建、启动、停止以及线程间通信等。使用QThread进行线程编程需要注意以下几个概念：

1. 线程的创建和启动：在Qt中，创建线程通常需要继承QThread类，并重载run()函数。在run()函数中编写线程的具体执行操作，并通过调用start()函数启动线程。

2. 线程的停止：为了确保线程安全，Qt建议使用abort()函数来终止线程，而不是一般的直接停止线程（如调用exit()或调用线程的析构函数）。

3. 信号与槽：Qt中的信号与槽机制是实现线程间通信的关键。通过信号与槽机制可以将多个线程之间的通信任务交给Qt处理，从而避免了手动处理多线程中的各种同步问题。

示例说明

示例一：多线程并发执行任务

在这个示例中，我们将演示如何使用QThread在一个简单的应用程序中实现多线程任务并发执行。具体操作如下：

1. 在主线程中新建一个子线程。

2. 在子线程中并发执行多个耗时任务。

3. 在主线程中通过信号槽机制接收子线程的任务执行结果。

示例代码如下：

// 创建自定义的线程类
class MyThread : public QThread
{
    Q_OBJECT
public:
    explicit MyThread(QObject *parent = 0) : QThread(parent){}
    void run()
    {
        // 模拟多个耗时任务
        for (int i = 0; i < 5; i++)
        {
            QString result = QString("task %1 finish.").arg(i);
            emit taskFinished(result);
            msleep(1000);
        }
    }
signals:
    void taskFinished(QString result);
};

// 主线程中处理任务执行结果的槽函数
void onTaskFinished(QString result)
{
    qDebug() << "Task finished:" << result;
}

// 在主函数中创建自定义线程，并启动子线程
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MyThread thread;
    QObject::connect(&thread, &MyThread::taskFinished, onTaskFinished);
    thread.start();
    return a.exec();
}

在这个示例中，我们定义了一个MyThread类，继承自QThread，并重载了其run()函数。在run()函数中，我们模拟了多个耗时任务，每个任务执行完成后，通过信号taskFinished()通知主线程任务已完成，并将任务执行结果作为信号参数传递出去。

在主函数中，我们先创建了一个MyThread类的实例，然后通过connect()函数将其信号taskFinished()连接到主线程的onTaskFinished()槽函数。最后，我们启动子线程并开始执行任务。

示例二：线程的同步与互斥

在这个示例中，我们将演示如何使用Qt的信号槽机制实现多线程间的同步与互斥。具体操作如下：

1. 在子线程中，通过信号槽机制向主线程发送数据请求，并等待主线程的回应。

2. 在主线程中处理数据请求，并通过信号槽机制向子线程发送数据回应。

3. 在子线程中接收到数据回应后，继续执行耗时任务。

示例代码如下：

// 子线程中向主线程发送数据请求的槽函数
void onRequestData()
{
    QString data = "requestData";
    emit dataRequest(data);

    // 等待主线程回应
    m_semaphore.acquire();
}

// 主线程中处理数据请求并向子线程发送数据回应的槽函数
void onDataRequest(QString data)
{
    qDebug() << "request data:" << data;
    QString responseData = "responseData";
    emit dataResponse(responseData);
}

// 子线程中接收到数据回应后继续执行耗时任务的槽函数
void onDataResponse(QString data)
{
    qDebug() << "response data:" << data;
    // 继续执行其他任务
}

// 在主函数中创建自定义线程，并启动子线程
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    // 创建自定义的线程类
    class MyThread : public QThread
    {
        Q_OBJECT
    public:
        explicit MyThread(QObject *parent = 0) : QThread(parent){}
        void run()
        {
            // 发送数据请求
            emit requestData();
            // 等待主线程回应
            m_semaphore.acquire();
            // 执行其他任务
            qDebug() << "start task...";
            msleep(5000);
        }
    signals:
        void requestData();
        void dataResponse(QString data);
    public slots:
        void onDataResponse(QString data)
        {
            // 接收到数据回应
            emit SemaphoreRelease();
            emit dataResponse(data);
        }
    private:
        QSemaphore m_semaphore;
    };

    MyThread thread;
    QObject::connect(&thread, &MyThread::requestData, onDataRequest);
    QObject::connect(&thread, &MyThread::dataResponse, &thread, &MyThread::onDataResponse);
    QObject::connect(&thread, &MyThread::SemaphoreRelease, [&thread](){
        thread.m_semaphore.release();
    });
    thread.start();
    return a.exec();
}

在这个示例中，我们改写了之前示例中的MyThread类，在其中添加了多个槽函数，实现了线程的同步与互斥机制。在run()函数中，我们先通过emit()函数向主线程发送数据请求，然后通过semaphore.acquire()等待主线程的回应，在接收到数据回应并执行了一部分任务后结束线程。主线程接收到数据请求后，触发onDataRequest()函数，并通过emit()函数向子线程发送数据回应。子线程接收到数据回应后，通过SemaphoreRelease()信号通知主线程已接收到回应，并通过emit()函数向线程内部发送数据回应。在主函数中，我们通过connect()函数将各个信号与槽函数连接起来，并启动子线程。

通过上述两个例子，我们了解了QThread线程组件的基本使用方法，并掌握了一些比较实用的线程编程技巧。