Qt201_QThread使用方法2：将任务类对象移动到子线程中

已于 2022-11-01 15:51:17 修改
阅读量917 收藏 5
点赞数
分类专栏： Qt 文章标签： qt ui
于 2022-11-01 15:15:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ckuanfeng/article/details/127634124
版权

步骤：

  1. 创建一个新的类，从QObject派生
  2. 类中添加一个共有的成员函数，子线程要执行的逻辑业务
  3. 在主线程中创建一个QThread对象，这就是子线程的对象
  4. 在主线程中创建工作的类对象(不要指定父对象)
  5. 将mywork对象移动到创建的子线程中去（QObject::moveToThread()方法）
  6. 启动子线程（ start() ）,这时候线程启动了，但是移动到线程中的对象并没有工作
  7. 调用mywork类对象的工作函数，这时候，是在移动到的那个子线程中运行的

Code：

主线程：

//widget.h

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include "mythread.h"

QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    QThread *thread1;
    QThread *thread2;
    QThread *thread3;
    MyThread *gen;
    BubbleSort *bubble;
    QuickSort *quick;
    ~Widget();

private slots:

private:
    Ui::Widget *ui;

signals:
    void starting(int num);
};
#endif // WIDGET_H

//widget.cpp

#include "widget.h"
#include "ui_widget.h"
#include "mythread.h"
#include <QString>
#include <QDebug>
#include <QThread>

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);

    //1，创建子线程对象
    thread1 = new QThread;
    thread2 = new QThread;
    thread3 = new QThread;

    //2，创建任务类对象
    gen = new MyThread;
    bubble = new BubbleSort;
    quick = new QuickSort;

    //3，将任务对象移动到子线程中
    gen -> moveToThread(thread1);
    bubble -> moveToThread(thread2);
    quick -> moveToThread(thread3);

    //4，启动子线程
    connect(this,&Widget::starting,gen,&MyThread::working);
    connect(ui->butStart,&QPushButton::clicked,[=]
    {
        emit starting(10000);
        thread1->start();
    });

    //5，将线程1返回的数据，交给线程2，3处理
    connect(gen,&MyThread::sendArray,bubble,&BubbleSort::working);
    connect(gen,&MyThread::sendArray,quick,&QuickSort::working);
    connect(gen,&MyThread::sendArray,[=](QVector<int> list){

        //启动其他两个子线程
        thread2->start();
        thread3->start();

        for(int i=0;i<list.size();i++)
        {
            ui -> randList -> addItem( QString::number( list.at(i) ));
        }
    });

    //将子线程2，3处理好返回的数据，在主线程显示
    connect(bubble,&BubbleSort::sendArray,[=](QVector<int> list){
        for(int i=0;i<list.size();i++)
        {
            ui ->buluList -> addItem( QString::number( list.at(i) ));
        }
    });

    connect(quick,&QuickSort::sendArray,[=](QVector<int> list){
        for(int i=0;i<list.size();i++)
        {
            ui -> quitList -> addItem( QString::number( list.at(i) ));
        }
    });

    //释放资源
    connect(this, &Widget::destroyed,this,[=]{
        qDebug()<<QString::fromLocal8Bit("资源1释放中，，，，，，，，，，，，");
        thread1 ->quit();
        thread1 -> wait();
        thread1 -> deleteLater();
        if(thread1 == nullptr)
            qDebug()<<QString::fromLocal8Bit("资源1释放完毕");
        qDebug()<<QString::fromLocal8Bit("资源2释放中，，，，，，，，，，，，");
        thread2 ->quit();
        thread2 -> wait();
        thread2 -> deleteLater();
        if(thread2 == nullptr)
            qDebug()<<QString::fromLocal8Bit("资源2释放完毕");
        qDebug()<<QString::fromLocal8Bit("资源3释放中，，，，，，，，，，，，");
        thread3 ->quit();
        thread3 -> wait();
        thread3 -> deleteLater();
        if(thread3 == nullptr)
            qDebug()<<QString::fromLocal8Bit("资源3释放完毕");
    });

}

Widget::~Widget()
{
    delete ui;
}

子线程：

//mythread.h

#ifndef MYTHREAD_H
#define MYTHREAD_H
#include <QThread>
#include <QVector>
#include <QObject>

class MyThread: public QObject
{
    Q_OBJECT
public:
    explicit MyThread(QObject *parent = nullptr);

    void working(int num);

private:

signals:

    void sendArray(QVector<int> array);

};


class BubbleSort: public QObject
{
    Q_OBJECT
public:

    explicit BubbleSort(QObject *parent = nullptr);

    void working(QVector<int> array);

private:

    void buluSort(QVector<int> &s);

signals:

    void sendArray(QVector<int> array);

};

class QuickSort: public QObject
{
    Q_OBJECT

public:

    explicit QuickSort(QObject *parent = nullptr);

    void Swap(int &a, int &b);

public slots:

    void working(QVector<int> list);

private:

    void quickSorts(QVector<int> &s, int l, int r);

signals:

    void sendArray(QVector<int> array);

};

#endif // MYTHREAD_H

//mythread.cpp

#include "mythread.h"
#include <QElapsedTimer>
#include <QDebug>
#include <QString>
#include <QThread>

MyThread::MyThread(QObject *parent):QObject(parent)
{

}
void MyThread::working(int num)
{
    qDebug()<<QString::fromLocal8Bit("当前线程地址为：")<<QThread::currentThread();

    QElapsedTimer timeLog;
    timeLog.start();
    QVector<int > list;
    for(int i = 0; i < num; i++)
    {
        list.push_back(rand()%100000);
    }
    int time = timeLog.elapsed();

    qDebug()<<QString::fromLocal8Bit("生成")<<num<<QString::fromLocal8Bit("个随机数用时 ")<<time<<QString::fromLocal8Bit(" 毫秒");
    emit sendArray(list);
}


BubbleSort::BubbleSort(QObject *parent):QObject(parent)
{

}

void BubbleSort::working(QVector<int> array)
{
    //sleep(2);
    qDebug()<<QString::fromLocal8Bit("冒泡线程地址为：")<<QThread::currentThread();
    QElapsedTimer timeLog;
    timeLog.start();
    if(array.size() == 0)
    {
        qDebug()<<QString::fromLocal8Bit("冒泡 数据为零");
    }
    buluSort(array);
    int time = timeLog.elapsed();
    qDebug()<<QString::fromLocal8Bit("冒泡排序用时： ")<<time<<QString::fromLocal8Bit(" 毫秒");
    emit sendArray(array);
}

void BubbleSort::buluSort(QVector<int> &s)
{
    qDebug()<<QString::fromLocal8Bit("冒泡排序中");
    int swp = 0;
    for(int i=0; i<s.size(); i++)
    {
        for(int j = 0; j < s.size() - i - 1; j++)
        {
            if(s[j]>s[j+1])
            {
                swp = s[j];
                s[j] = s[j+1];
                s[j+1] = swp;
            }
        }
    }
}


QuickSort::QuickSort(QObject *parent):QObject(parent)
{

}

void QuickSort::working(QVector<int> list)
{
    //sleep(1);
    auto str = QString::fromLocal8Bit("选择排序线程地址为：");
    qDebug()<< str << QThread::currentThread();
    QElapsedTimer timeLog;
    timeLog.start();
    if(list.size() == 0)
    {
        qDebug()<<QString::fromLocal8Bit("选择数据为零");
    }
    quickSorts(list,0,list.size());
    int time = timeLog.elapsed();
    qDebug()<<QString::fromLocal8Bit("选择排序用时： ")<<time<<QString::fromLocal8Bit(" 毫秒");
    emit sendArray(list);
}

void QuickSort::quickSorts(QVector<int> &data, int low, int high)
{
    qDebug()<<QString::fromLocal8Bit("选择排序中");
    int min = 0;
    for(int i=0;i<data.size();i++)
     {
       min = i;
       for(int j=i+1;j<data.size();j++)
       {
         if(data[min]>data[j])
         {
           min = j;
         }
       }
       int temp = data[min];
       data[min] = data[i];
       data[i] = temp;
     }
}
void QuickSort::Swap(int &a, int &b)
{
    int swp = a;
    a = b;
    b = swp;
}

资源回收：

  1. 创建线程对象时，指定父对象。（QThread   t1 = new QThread (this) ;
  2. 在窗口类的析构函数中，释放资源。
  3. 通过Widget::destoryed信号来释放资源（见widget.cpp中 释放资源）：
山海不朽
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
QT 主线程子线程互相传值
断点
12-02 1万+
QT多线程专栏共有14篇文章，从初识线程到、QMutex锁、QSemaphore信号量、Emit、Sgnals、Slot主线程子线程互相传值同步变量、QWaitCondition、事件循环、QObjects、线程安全、线程同步、线程异步、QThreadPool线程池等线程操作进行了全面！深入！的研究和详细的说明
Qt/C++在子线程执行函数的三种方法
左霖风的博客
12-20 5748
1、使用QtConcurrent 前言： QtConcurrent 是命名空间 (namespace)，它提供了高层次的函数接口 (APIs)，使所写程序，可根据计算机的 CPU 核数，自动调整运行的线程数目。 1.1、 函数原型 QFuture<T> QtConcurrent::run(QThreadPool::globalInstance(), function, ...) ; ......
Qt move to thread 移动到新线程注意事项
StringerChen的博客
01-30 1247
使用move to thread接口移动到新线程时，新线程如果有指针成员变量的话，也要把指针成员变量一起移动到新线程内，不然指针的成员变量还在主线程，特别的tcp、tdp等比较耗时的对象。
Qt子线程更新数据发到主线程显示.rar
08-18
Qt的子线程无法直接更新主UI，需要发送信号到主线程进行更新，我用的QTableWidget展示数据。
qt中若有一条子线程已经在运行了，在子线程运行过程中如何在主线程传递参数给该子线程
weixin_43972388的博客
06-30 517
我们还使用了QMetaObject::invokeMethod()方法，在子线程中调用doWork()函数，并传递参数。总结起来，你可以使用QMetaObject::invokeMethod()方法在主线程中向正在运行的子线程传递参数。需要注意的是，使用QMetaObject::invokeMethod()方法可以在运行中的子线程中调用对应的函数，并传递参数。在Qt中，如果子线程已经在运行，可以通过信号与槽机制来在主线程和子线程之间传递参数。在这个示例中，我们创建了一个Worker类作为线程的工作对象。
pyqt主线程给子线程传递参数的方法
qq_41255416的博客
05-18 6898
由于自己做的pyqt界面经常出现假死，本人实在不堪其扰，所以想学一下多线程。 话不多说，直接进入正题。 我们都知道子线程给ui主线程传递参数可以通过pyqtsignal方式来传递，但是主线程给子线程传递参数却很少人用 #方法一：全局变量法 import cv2 from PyQt5 import QtCore, QtWidgets from PyQt5.QtCore import QThread, pyqtSignal, QDateTime from PyQt5.QtWidgets import QApp
qt中多线程类qthread的介绍和使用方法.pdf
11-17
本文将深入探讨Qt中QThread的介绍、使用方法以及与多线程相关的知识点。 首先，QThread类在Qt4中被设计为继承自QObject，这使得QThread对象可以利用Qt的信号槽机制，允许在不同线程之间安全地通信。而在Qt3中，线程...
qt中多线程类qthread的介绍和使用方法.docx
11-29
QT中的多线程类QThread是C++编程中处理并发执行任务的重要工具，尤其在GUI应用程序中，它能帮助我们避免主线程阻塞，保证用户界面的流畅性。QThread提供了一个相对简单的方式来管理和控制线程，使得我们可以将耗时的...
c++与Qt实现把定时器放进子线程中运行
03-02
Qt中把QTimer放进子线程中执行，同时，把主ui线程中的定时器槽函数，同步移动到子线程执行。本样例，实现了，QTimer在子线程运行，QTimer的槽函数与自己均在同一个子线程中运行。
pyqt5中QThread在使用时出现重复emit的实例
09-19
QThread是一个线程类，它提供了事件循环，允许在子线程中运行Qt对象。发射信号（emit）是Qt事件驱动模型的一部分，用来在对象之间传递信息。当一个信号被发射时，与其连接的槽函数会被调用。 在上述代码实例中，`...
Qt创建线程的两种方式+线程池方式
最新发布
04-29
2.方式2：使用类对象的 moveToThread() 方式：将对象移动到线程中，并在线程中手动调用对象的工作函数来创建线程。 优点：对象与线程分离，使得线程逻辑和对象逻辑分离，提高了代码的可维护性和灵活性；可以将一个...
Qt中Tree Widget控件的使用
晓琴儿
10-15 2272
0x00 使用Tree Widget控件制作树形菜单(效果图如下) 0x01 代码如下 #ifndef MAINWIDGET_H #define MAINWIDGET_H #include <QWidget> QT_BEGIN_NAMESPACE namespace Ui { class MainWidget; } QT_END_NAMESPACE class MainWidget : public QWidget { Q_OBJECT public: ...
QT QTcpServer多线程并发，主线程与子线程之间传递参数
思月亮卷的专栏
09-16 1935
QT 的网络通讯，并且要多线程并发的同时，还得主线程跟子线程之间传递参数
Qt中UI对象只能在主线程中操作，那如何在子线程中操作UI呢
weixin_39390491的博客
03-24 2848
Qt中UI对象只能在主线程中操作，那如何在子线程中操作UI呢？
Qt多线程间信号槽传递非QObject类型对象的参数
qqwangfan的专栏
12-02 3226
多线程间需要传递信号给另外一个线程的槽，而信号和槽所使用的参数为非QObject，无论其是stl的标准库类型还是其他类型，都必须先注册，否则信号发送了，槽将会始终不调用。 注册方式如下： #include  //该文件为qRegisterMetaType所在头文件，也可以使用 #include 此头文件包括了所有的qt类型头文件 qRegisterMetaType("type"); 如我
Qt使用多线程的一些心得——1.继承QThread的多线程使用方法
热门推荐
尘中远的程序开发记录
03-22 11万+
摘要 Qt多线程方法1 继承QThread 1写一个继承于QThread的线程 2 QThread的几个函数quitexitterminate函数 3 正确的终止一个线程 4 如何正确启动一个线程 41正确的启动一个全局线程和UI一直存在的线程 42 如何启动一个局部线程用完即释放的线程 继承QThread的一些总结 使用QObject实现多线的方法见：http://blog.csdn.net/cz
Qt线程之moveToThread
lhw330472787的博客
08-03 587
Qt线程之moveToThread。 moveToThread的函数声明是： void moveToThread(QThread *targetThread) 。。具体的使用步骤如下： 1.从QObject派生一个类，将耗时的工作写在该类的槽函数中。 2.将派生类对象移动到一个QThread中，该线程需要start。（这一步使用moveToThread） 3.通过信号连接派生类的槽函数，并通过信号触发槽函数。(槽函数在子线程中执行) 用实例说话： 1.老样子，用QtCreator新建一个基于QWidget的
Qt中通过信号和槽在子线程和主线程中进行数据传递
苦茶Fighting的博客
09-12 4509
QT中两个线程之间进行自定义类型数据传递 两个线程中进行数据传递时，传递的数据放到队列中(queue)，所以在这个过程中，需要在传递前将数据拷贝、存储到队列中；为了存储这些参数，Qt需要construct、destruct、copy这些对象，为了让Qt知道怎样去做这些事情，参数类型需要进行注册。详细步骤分为三步： 加入头文件#include &lt;QMetaType&gt; 声明要传递的参...
c++ qt 将多个任务移动到同一个线程中
05-25
在Qt中，可以使用`QThread`类来创建和管理线程。要将多个任务移动到同一个线程中，可以创建一个`QObject`子类，并将其移动到目标线程中。然后，在该对象中定义多个方法来执行不同的任务。在主线程中，创建该对象的实例，然后使用`QMetaObject::invokeMethod`方法将需要执行的任务发送到目标线程中。 以下是一个简单的示例： ``` class MyObject : public QObject { Q_OBJECT public: MyObject(QObject* parent = nullptr) : QObject(parent) {} public slots: void task1() { // 执行任务1 } void task2() { // 执行任务2 } }; int main(int argc, char* argv[]) { QApplication a(argc, argv); QThread thread; MyObject* myObject = new MyObject(); myObject->moveToThread(&thread); thread.start(); // 在主线程中执行任务1 QMetaObject::invokeMethod(myObject, "task1", Qt::QueuedConnection); // 在主线程中执行任务2 QMetaObject::invokeMethod(myObject, "task2", Qt::QueuedConnection); return a.exec(); } ``` 在上面的示例中，`MyObject`类定义了两个槽函数 `task1` 和 `task2`，分别用于执行任务1和任务2。在`main`函数中，首先创建一个`QThread`实例和一个`MyObject`实例，并将`MyObject`实例移动到`QThread`中。然后，使用`QMetaObject::invokeMethod`方法将两个任务发送到`MyObject`实例所在的目标线程中执行。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值