QT线程模块使用QThtead

已于 2023-09-15 19:15:18 修改
阅读量211 收藏
点赞数
分类专栏： QT 文章标签： qt java linux
于 2023-07-19 22:22:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58233509/article/details/131819175
版权
文章展示了在Qt环境中使用QThread、QObject以及QtConcurrent实现多线程的方法。通过重写QThread的run方法或让类继承QObject并使用QRunnable，实现了数据生成、冒泡排序和快速排序的异步处理。同时，提到了线程池的使用，通过QThreadPool管理任务，根据系统资源动态调整线程数量。
摘要由CSDN通过智能技术生成

第一种方式：重写Qthread里的run方法

main.cpp

#include "mainwindow.h"

#include <QApplication>

int main(int argc, char* argv[])
{
    QApplication a(argc, argv);
    qRegisterMetaType<QVector<int>>("QVector<int>"); //注册 使用
    MainWindow w;

    w.show();
    return a.exec();
}

mainwindow.cpp

#include "mainwindow.h"
#include "mythread.h"
#include "ui_mainwindow.h"
#include <QLabel>
#include <QPushButton>
#include <QThread>

MainWindow::MainWindow(QWidget* parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    //创建子线程

    Generate* gen = new Generate(this);
    Quicksort* quick = new Quicksort(this);
    Bubblesort* bubble = new Bubblesort(this);

    connect(this, &MainWindow::starting, gen, &Generate::recvNum);

    connect(ui->startBtn, &QPushButton::clicked, this, [=]() {
        emit this->starting(100000);        //启动线程
        gen->start(); });
    //接受数据
    connect(gen, &Generate::sayNum, quick, &Quicksort::recvArry);
    connect(gen, &Generate::sayNum, bubble, &Bubblesort::recvArry);
    //接受数据
    connect(gen, &Generate::sayNum, this, [=](QVector<int> v) {
        //接收到数据证明程序已经启动了 ，
        quick->start();
        bubble->start();
        //显示
        for (int i = 0; i < v.size(); ++i) {
            ui->randomList->addItem(QString::number(v.at(i)));
        }
        
    });
    //冒泡
    connect(bubble, &Bubblesort::finish, this, [=](QVector<int> v) {
        //        qDebug()<<"冒泡显示";
        //接收到数据证明程序已经启动了
        for (int i = 0; i < v.size(); ++i) {
            ui->bubbleList->addItem(QString::number(v.at(i)));
        }
    });

    //    //快排序
    connect(quick, &Quicksort::finish, this, [=](QVector<int> v) {
        //接收到数据证明程序已经启动了 ，
        //        qDebug() << "内置排序";
        for (int i = 0; i < v.size(); ++i) {
            ui->quickList->addItem(QString::number(v.at(i)));
        }
    });
}

void MainWindow::subThread()
{
    int num = 0;
    while (1) {
        num++;
        if (num == 100000) {
            break;
        }
        label->setText(QString::number(num));
        QThread::sleep(1);
    }
}

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

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QLabel>
#include <QMainWindow>
QT_BEGIN_NAMESPACE
namespace Ui {
class MainWindow;
}
QT_END_NAMESPACE

class MainWindow : public QMainWindow {
    Q_OBJECT

public:
    MainWindow(QWidget* parent = nullptr);
    ~MainWindow();
    void subThread();
    QLabel* label;

private:
    Ui::MainWindow* ui;
signals:
    void starting(int num);
};
#endif // MAINWINDOW_H

mythread.h

#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QThread>
#include <QWidget>
class Generate : public QThread {
    Q_OBJECT
public:
    explicit Generate(QWidget* parent = nullptr);
    void recvNum(int num);

signals:
    void sayNum(QVector<int>);

protected:
    void run() override;

private:
    int num;
};
//冒泡排序
class Bubblesort : public QThread {
    Q_OBJECT
public:
    explicit Bubblesort(QWidget* parent = nullptr);
    void recvArry(QVector<int>);

signals:
    void finish(QVector<int>);

protected:
    void run() override;

private:
    QVector<int> v;
};
//快速排序

class Quicksort : public QThread {
    Q_OBJECT
public:
    explicit Quicksort(QWidget* parent = nullptr);
    void recvArry(QVector<int>);

signals:
    void finish(QVector<int>);

protected:
    void run() override;

private:
    QVector<int> v;
};

#endif // MYTHREAD_H

mythread.cpp

#include "mythread.h"
#include <QElapsedTimer>
#include <QRandomGenerator>
#include <QVector>

Generate::Generate(QWidget* parent)
    : QThread { parent }
{
}
void Generate::run()
{
    qDebug() << "线程运行了,线程地址是" << Generate::currentThread();

    QVector<int> v;
    QElapsedTimer time;
    time.start();
    for (int i = 0; i < this->num; i++) {
        //        v.push_back(rand() % 10000);
        v.push_back(QRandomGenerator::global()->bounded(0, 1000));
    }
    int milsec = time.elapsed();
    qDebug() << "生成" << num << "个随机数"
             << "耗时" << milsec << "毫秒";
    emit this->sayNum(v);
}

void Generate::recvNum(int num)
{
    this->num = num;
}

//冒泡代码

Bubblesort::Bubblesort(QWidget* parent)
    : QThread(parent)
{
}

void Bubblesort::recvArry(QVector<int> v)
{
    this->v = v;
}

void Bubblesort::run()
{

    QElapsedTimer timer;
    timer.start();
    //冒泡排序
    qDebug() << "冒泡" << QThread::currentThread();
    for (int i = 0; i < v.size(); ++i) {
        for (int j = 0; j < v.size() - i - 1; ++j) {
            if (v[j] > v[j + 1]) {
                int temp = v[j];
                v[j] = v[j + 1];
                v[j + 1] = temp;
            }
        }
    }
    int milsec = timer.elapsed();
    qDebug() << "冒泡耗时" << milsec << "毫秒";
    emit finish(v);
};

//快速排序
Quicksort::Quicksort(QWidget* parent)
    : QThread(parent)
{
}

void Quicksort::recvArry(QVector<int> v)
{
    this->v = v;
}

void Quicksort::run()
{
    QElapsedTimer timer;
    timer.start();
    //快排序
    qDebug() << "快速排序" << QThread::currentThread();
    std::sort(v.begin(), v.end());

    int milsec = timer.elapsed();
    qDebug() << "快排耗时" << milsec << "毫秒";
    emit finish(v);
};

thread.pro

QT       += core gui

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

CONFIG += c++17

# You can make your code fail to compile if it uses deprecated APIs.
# In order to do so, uncomment the following line.
#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0

SOURCES += \
    main.cpp \
    mainwindow.cpp \
    mythread.cpp

HEADERS += \
    mainwindow.h \
    mythread.h

FORMS += \
    mainwindow.ui

# Default rules for deployment.
qnx: target.path = /tmp/$${TARGET}/bin
else: unix:!android: target.path = /opt/$${TARGET}/bin
!isEmpty(target.path): INSTALLS += target

mainwindow.ui / ui_mainwindow.h

/********************************************************************************
** Form generated from reading UI file 'mainwindow.ui'
**
** Created by: Qt User Interface Compiler version 6.3.1
**
** WARNING! All changes made in this file will be lost when recompiling UI file!
********************************************************************************/

#ifndef UI_MAINWINDOW_H
#define UI_MAINWINDOW_H

#include <QtCore/QVariant>
#include <QtWidgets/QApplication>
#include <QtWidgets/QGroupBox>
#include <QtWidgets/QHBoxLayout>
#include <QtWidgets/QListWidget>
#include <QtWidgets/QMainWindow>
#include <QtWidgets/QMenuBar>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QStatusBar>
#include <QtWidgets/QVBoxLayout>
#include <QtWidgets/QWidget>

QT_BEGIN_NAMESPACE

class Ui_MainWindow
{
public:
    QWidget *centralwidget;
    QVBoxLayout *verticalLayout_2;
    QWidget *widget;
    QHBoxLayout *horizontalLayout_3;
    QGroupBox *groupBox;
    QVBoxLayout *verticalLayout;
    QListWidget *randomList;
    QGroupBox *groupBox_2;
    QHBoxLayout *horizontalLayout;
    QListWidget *bubbleList;
    QGroupBox *groupBox_3;
    QHBoxLayout *horizontalLayout_2;
    QListWidget *quickList;
    QPushButton *startBtn;
    QMenuBar *menubar;
    QStatusBar *statusbar;

    void setupUi(QMainWindow *MainWindow)
    {
        if (MainWindow->objectName().isEmpty())
            MainWindow->setObjectName(QString::fromUtf8("MainWindow"));
        MainWindow->resize(800, 600);
        centralwidget = new QWidget(MainWindow);
        centralwidget->setObjectName(QString::fromUtf8("centralwidget"));
        verticalLayout_2 = new QVBoxLayout(centralwidget);
        verticalLayout_2->setObjectName(QString::fromUtf8("verticalLayout_2"));
        widget = new QWidget(centralwidget);
        widget->setObjectName(QString::fromUtf8("widget"));
        horizontalLayout_3 = new QHBoxLayout(widget);
        horizontalLayout_3->setObjectName(QString::fromUtf8("horizontalLayout_3"));
        groupBox = new QGroupBox(widget);
        groupBox->setObjectName(QString::fromUtf8("groupBox"));
        verticalLayout = new QVBoxLayout(groupBox);
        verticalLayout->setObjectName(QString::fromUtf8("verticalLayout"));
        randomList = new QListWidget(groupBox);
        randomList->setObjectName(QString::fromUtf8("randomList"));

        verticalLayout->addWidget(randomList);


        horizontalLayout_3->addWidget(groupBox);

        groupBox_2 = new QGroupBox(widget);
        groupBox_2->setObjectName(QString::fromUtf8("groupBox_2"));
        horizontalLayout = new QHBoxLayout(groupBox_2);
        horizontalLayout->setObjectName(QString::fromUtf8("horizontalLayout"));
        bubbleList = new QListWidget(groupBox_2);
        bubbleList->setObjectName(QString::fromUtf8("bubbleList"));

        horizontalLayout->addWidget(bubbleList);


        horizontalLayout_3->addWidget(groupBox_2);

        groupBox_3 = new QGroupBox(widget);
        groupBox_3->setObjectName(QString::fromUtf8("groupBox_3"));
        horizontalLayout_2 = new QHBoxLayout(groupBox_3);
        horizontalLayout_2->setObjectName(QString::fromUtf8("horizontalLayout_2"));
        quickList = new QListWidget(groupBox_3);
        quickList->setObjectName(QString::fromUtf8("quickList"));

        horizontalLayout_2->addWidget(quickList);


        horizontalLayout_3->addWidget(groupBox_3);


        verticalLayout_2->addWidget(widget);

        startBtn = new QPushButton(centralwidget);
        startBtn->setObjectName(QString::fromUtf8("startBtn"));

        verticalLayout_2->addWidget(startBtn);

        MainWindow->setCentralWidget(centralwidget);
        menubar = new QMenuBar(MainWindow);
        menubar->setObjectName(QString::fromUtf8("menubar"));
        menubar->setGeometry(QRect(0, 0, 800, 26));
        MainWindow->setMenuBar(menubar);
        statusbar = new QStatusBar(MainWindow);
        statusbar->setObjectName(QString::fromUtf8("statusbar"));
        MainWindow->setStatusBar(statusbar);

        retranslateUi(MainWindow);

        QMetaObject::connectSlotsByName(MainWindow);
    } // setupUi

    void retranslateUi(QMainWindow *MainWindow)
    {
        MainWindow->setWindowTitle(QCoreApplication::translate("MainWindow", "MainWindow", nullptr));
        groupBox->setTitle(QCoreApplication::translate("MainWindow", "\351\232\217\346\234\272\346\225\260", nullptr));
        groupBox_2->setTitle(QCoreApplication::translate("MainWindow", "\345\206\222\346\263\241\346\216\222\345\272\217", nullptr));
        groupBox_3->setTitle(QCoreApplication::translate("MainWindow", "\345\277\253\351\200\237\346\216\222\345\272\217", nullptr));
        startBtn->setText(QCoreApplication::translate("MainWindow", "\345\274\200\345\247\213", nullptr));
    } // retranslateUi

};

namespace Ui {
    class MainWindow: public Ui_MainWindow {};
} // namespace Ui

QT_END_NAMESPACE

#endif // UI_MAINWINDOW_H

第二种方式：继承QObject对象

mainwindow.cpp

#include "mainwindow.h"
#include "mythread.h"
#include "ui_mainwindow.h"
#include <QLabel>
#include <QPushButton>
#include <QThread>

MainWindow::MainWindow(QWidget* parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    //创建子线程

    Generate* gen = new Generate;
    Quicksort* quick = new Quicksort;
    Bubblesort* bubble = new Bubblesort;
    //创建任务类
    QThread* thread1 = new QThread;
    QThread* thread2 = new QThread;
    QThread* thread3 = new QThread;
    //将任务对象移入
    gen->moveToThread(thread1);
    quick->moveToThread(thread2);
    bubble->moveToThread(thread3);

    connect(this, &MainWindow::starting, gen, &Generate::working);

    connect(ui->startBtn, &QPushButton::clicked, this, [=]() {
        emit this->starting(10000);        //启动线程
        thread1->start(); });

    //接受数据
    connect(gen, &Generate::sayNum, quick, &Quicksort::working);
    connect(gen, &Generate::sayNum, bubble, &Bubblesort::working);
    //    connect(gen, &Generate::sayNum, this, [=](QVector<int> v) {
    //        quick->working(v);
    //        bubble->working(v);
    //    }); //错误写法，在主线程运行了

    //接受数据
    connect(gen, &Generate::sayNum, this, [=](QVector<int> v) {
        //接收到数据证明程序已经启动了 ，
        thread2->start();
        thread3->start();
        //显示
        for (int i = 0; i < v.size(); ++i) {
            ui->randomList->addItem(QString::number(v.at(i)));
        }
    });
    //冒泡
    connect(bubble, &Bubblesort::finish, this, [=](QVector<int> v) {
        //        qDebug()<<"冒泡显示";
        //接收到数据证明程序已经启动了
        for (int i = 0; i < v.size(); ++i) {
            ui->bubbleList->addItem(QString::number(v.at(i)));
        }
    });

    //    //快排序
    connect(quick, &Quicksort::finish, this, [=](QVector<int> v) {
        //接收到数据证明程序已经启动了 ，
        //        qDebug() << "内置排序";
        for (int i = 0; i < v.size(); ++i) {
            ui->quickList->addItem(QString::number(v.at(i)));
        }
    });
    connect(this, &QWidget::destroyed, this, [=]() {
        thread1->quit();
        thread1->wait();
        thread1->deleteLater();

        thread2->quit();
        thread2->wait();
        thread2->deleteLater();

        thread3->quit();
        thread3->wait();
        thread3->deleteLater();
    });
}

void MainWindow::subThread()
{
    int num = 0;
    while (1) {
        num++;
        if (num == 100000) {
            break;
        }
        label->setText(QString::number(num));
        QThread::sleep(1);
    }
}

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

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QLabel>
#include <QMainWindow>
QT_BEGIN_NAMESPACE
namespace Ui {
class MainWindow;
}
QT_END_NAMESPACE

class MainWindow : public QMainWindow {
    Q_OBJECT

public:
    MainWindow(QWidget* parent = nullptr);
    ~MainWindow();
    void subThread();
    QLabel* label;

private:
    Ui::MainWindow* ui;
signals:
    void starting(int num);
};
#endif // MAINWINDOW_H

线程池使用

继承QRunnable重写run方法，run方法是公共函数

thread.cpp

#include "mythread.h"
#include <QElapsedTimer>
#include <QObject>
#include <QRandomGenerator>
#include <QRunnable>
#include <QVector>

Generate::Generate(QWidget* parent)
    : QObject(parent)
    , QRunnable()
{
    setAutoDelete(true);
}
void Generate::run()
{
    qDebug() << "线程运行了,线程地址是" << QThread::currentThread();

    QVector<int> v;
    QElapsedTimer time;
    time.start();
    for (int i = 0; i < this->num; i++) {
        //        v.push_back(rand() % 10000);
        v.push_back(QRandomGenerator::global()->bounded(0, 1000));
    }
    int milsec = time.elapsed();
    qDebug() << "生成" << num << "个随机数"
             << "耗时" << milsec << "毫秒";
    emit this->sayNum(v);
}

void Generate::recvNum(int num)
{
    this->num = num;
}

//冒泡代码

Bubblesort::Bubblesort(QWidget* parent)
    : QObject(parent)
    , QRunnable()

{
    setAutoDelete(true);
}

void Bubblesort::recvArry(QVector<int> v)
{
    this->v = v;
}

void Bubblesort::run()
{

    QElapsedTimer timer;
    timer.start();
    //冒泡排序
    qDebug() << "冒泡" << QThread::currentThread();
    for (int i = 0; i < v.size(); ++i) {
        for (int j = 0; j < v.size() - i - 1; ++j) {
            if (v[j] > v[j + 1]) {
                int temp = v[j];
                v[j] = v[j + 1];
                v[j + 1] = temp;
            }
        }
    }
    int milsec = timer.elapsed();
    qDebug() << "冒泡耗时" << milsec << "毫秒";
    emit finish(v);
};

//快速排序
Quicksort::Quicksort(QWidget* parent)
    : QObject(parent)
    , QRunnable()

{
    setAutoDelete(true);
}

void Quicksort::recvArry(QVector<int> v)
{
    this->v = v;
}

void Quicksort::run()
{
    QElapsedTimer timer;
    timer.start();
    //快排序
    qDebug() << "快速排序" << QThread::currentThread();
    std::sort(v.begin(), v.end());

    int milsec = timer.elapsed();
    qDebug() << "快排耗时" << milsec << "毫秒";
    emit finish(v);
};

thread.h

#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QObject>
#include <QRunnable>
#include <QThread>
#include <QWidget>
class Generate : public QObject, public QRunnable {
    Q_OBJECT
public:
    explicit Generate(QWidget* parent = nullptr);
    void recvNum(int num);
    void run() override;

signals:
    void sayNum(QVector<int>);

protected:
private:
    int num;
};
//冒泡排序
class Bubblesort : public QObject, public QRunnable {
    Q_OBJECT
public:
    explicit Bubblesort(QWidget* parent = nullptr);
    void recvArry(QVector<int>);
    void run() override;

signals:
    void finish(QVector<int>);

private:
    QVector<int> v;
};
//快速排序

class Quicksort : public QObject, public QRunnable {
    Q_OBJECT
public:
    explicit Quicksort(QWidget* parent = nullptr);
    void recvArry(QVector<int>);
    void run() override;

signals:
    void finish(QVector<int>);

private:
    QVector<int> v;
};

#endif // MYTHREAD_H

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QLabel>
#include <QMainWindow>
QT_BEGIN_NAMESPACE
namespace Ui {
class MainWindow;
}
QT_END_NAMESPACE

class MainWindow : public QMainWindow {
    Q_OBJECT

public:
    MainWindow(QWidget* parent = nullptr);
    ~MainWindow();
    void subThread();
    QLabel* label;

private:
    Ui::MainWindow* ui;
signals:
    void starting(int num);
};
#endif // MAINWINDOW_H

maindindow.cpp

#include "mainwindow.h"
#include "mythread.h"
#include "ui_mainwindow.h"
#include <QLabel>
#include <QPushButton>
#include <QThread>
#include <QThreadPool>
MainWindow::MainWindow(QWidget* parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    //创任务类；

    Generate* gen = new Generate;
    Quicksort* quick = new Quicksort;
    Bubblesort* bubble = new Bubblesort;

    connect(this, &MainWindow::starting, gen, &Generate::recvNum);

    connect(ui->startBtn, &QPushButton::clicked, this, [=]() {
        emit this->starting(100000); //启动线程
        //        gen->start();
        QThreadPool::globalInstance()->start(gen);
    });
    //接受数据
    connect(gen, &Generate::sayNum, quick, &Quicksort::recvArry);
    connect(gen, &Generate::sayNum, bubble, &Bubblesort::recvArry);
    //接受数据
    connect(gen, &Generate::sayNum, this, [=](QVector<int> v) {
        //接收到数据证明程序已经启动了 ，
        //        quick->start();
        //        bubble->start();
        QThreadPool::globalInstance()->start(quick);
        QThreadPool::globalInstance()->start(bubble);

        //显示
        for (int i = 0; i < v.size(); ++i) {
            ui->randomList->addItem(QString::number(v.at(i)));
        }
    });
    //冒泡
    connect(bubble, &Bubblesort::finish, this, [=](QVector<int> v) {
        //        qDebug()<<"冒泡显示";
        //接收到数据证明程序已经启动了
        for (int i = 0; i < v.size(); ++i) {
            ui->bubbleList->addItem(QString::number(v.at(i)));
        }
    });

    //    //快排序
    connect(quick, &Quicksort::finish, this, [=](QVector<int> v) {
        //接收到数据证明程序已经启动了 ，
        //        qDebug() << "内置排序";
        for (int i = 0; i < v.size(); ++i) {
            ui->quickList->addItem(QString::number(v.at(i)));
        }
    });
}

void MainWindow::subThread()
{
    int num = 0;
    while (1) {
        num++;
        if (num == 100000) {
            break;
        }
        label->setText(QString::number(num));
        QThread::sleep(1);
    }
}

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

QtConcurrent高级API使用

Concurrent是并发的意思，QtConcurrent是一个命名空间，提供了一些高级的 API，使得在编写多线程的时候，无需使用低级线程原语，如读写锁，等待条件或信号。使用QtConcurrent编写的程序会根据可用的处理器内核数自动调整使用的线程数。这意味着今后编写的应用程序将在未来部署在多核系统上时继续扩展。
简单的说，QtConcurrent::run()函数会在一个单独的线程中执行，并且该线程取自全局QThreadPool，该函数的返回值通过QFuture API提供。
请注意：该函数可能不会立即运行; 函数只有在线程可用时才会运行。
通过QtConcurrent::run()返回的QFuture不支持取消、暂停，返回的QFuture只能用于查询函数的运行/完成状态和返回值

QT4版本需要添加<QtCore>头文件 Qt5需要pro文件添加 QT+= concurrent

void MainWindow::btnClick(){
    qDebug()<<"点击";
//    Qwidget* parent =0;
//    QFuture<void>f1 = QtConcurrent::run(func,QString("aa"));
//    f1.waitForFinished();
#if 1

    QFuture<void>    future = QtConcurrent::run(this,&MainWindow::func,QString("aa"));
    QFuture<void> f2 =QtConcurrent::run(this,&MainWindow::func,QString("aaa"));
//    qDebug()<<"filesh";
//函数指针的一个实现   
 void (MainWindow::*f)(QString);
    f = &MainWindow::func;
    func("fdas");
    (this->*(f))("test");

//    QFuture<void> f1 =QtConcurrent::run(f,QString("aa"));
//    f1.waitForFinished();

    QByteArray bytearray = "hello world";
    QFuture<QList<QByteArray> > future1 = QtConcurrent::run(bytearray, &QByteArray::split, ' ');
    qDebug()<< future1.result();

#else
    QFuture < void > future =  QtConcurrent::run([=](){
        qDebug() <<"1"<< __FUNCTION__  << QThread::currentThreadId() << QThread::currentThread();
    });
    QFuture < void > future2 = QtConcurrent::run([=](){
        qDebug() <<"2 "<< __FUNCTION__  << QThread::currentThreadId() << QThread::currentThread();
    });
#endif

only-lucky
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
QThread资料
09-21
本资源是关于QThread如何正确使用的资源，里面有篇国外分析的资料，讲的很好
QThread的用法！qt多线程编程
hufeng825的专栏
07-21 3168
<br />QThread的用法！分类： QT-trolltech2007-08-01 15:17<br />#include <qthread.h><br />    class MyThread : public QThread {<br />    public:<br />        virtual void run();<br />    };<br /><br />    void MyThread::run()<br />    {<br />        for( int count
一个QThread例子
xiaoyangger的专栏
01-30 2232
//threadTest.h #ifndef THREADTEST_H #define THREADTEST_H #include #include "test.h"class MyThread : public QThread {      protected :     virtual void run(); }; MyThread myThrea
QThread类参考
Zender
07-26 285
先给出转载网址：Qthread同时增加了一些自己的理解QThread类提供了与系统无关的线程。#include <qthread.h>继承了Qt。所有成员函数的列表。公有成员QThread () virtual ~QThread () bool wait ( unsigned long time = ULONG_MAX ) void start () bool finished () const b
使用QThread实现多线程
carrottttt的博客
03-29 298
basethread.h #ifndef BASETHREAD_H #define BASETHREAD_H #include <QObject> #include <QThread> #include <QDebug> #include <qthread.h> /*****************************************/ class BaseThread :public QObject { Q_OBJECT public:
qt websocket 客户端 多线程使用
09-16
qt 使用QWebSocket 创建websocket客户端来读取数据，异步链接，并且放入到线程中去执行，线程池的基础，代码使用两个用户，放入到一个线程中执行，同理，可以多个用户放入到多个线程中执行，为线程池执行websocket ...
Qt 多线程使用串口源码下载
12-26
本教程将聚焦于如何在Qt中利用多线程来操作串口（QSerialPort），这是在嵌入式系统、工业设备通信等领域常见的需求。 首先，让我们了解QSerialPort模块。它是Qt的一个部分，提供了一种简单的方式来与串行端口进行...
Qt 线程串口读写串口数据
11-13
在本文中，我们将深入探讨如何使用Qt框架进行线程化串口读写操作。Qt是一个功能强大的跨平台应用程序开发框架，特别适用于GUI编程。在处理串口通信时，由于串口操作通常涉及到I/O密集型任务，直接在主线程中进行可能...
qt编写的Udp使用线程通信
09-06
本篇将深入解析如何在Qt环境中使用线程来实现UDP通信。 首先，理解UDP协议是至关重要的。UDP是一种无连接的、不可靠的传输层协议，它不保证数据包的顺序或完整性，但具有低延迟和高效能的优点。在实时音视频传输、...
linux下Qt编译带qthread.h或mqueue.h文件函数的方法
阿猪米德的小本本
05-16 993
linux下Qt编译带qthread.h或mqueue.h文件函数的方法 一、在终端编译时添加后缀 带有qthread.h文件函数的，在编译时添加-lpthread，如图： 带有mqueue.h文件函数的，在编译时添加-lrt，如图： 二、在Qt上构建带有qthread.h文件函数的方法： 在.pro内部添加LIBS += qthread 即可构建成功。 阿猪米德 2019.05.16于湖北...
QThread的用法
weixin_65147589的博客
08-06 404
pyqt5
QT从入门到入土（五（1））——多线程（QThread）
明月清风@的博客
07-20 1307
引言 前面几篇已经对C++的线程做了简单的总结，浅谈C++11中的多线程(三) - 唯有自己强大 - 博客园 (cnblogs.com)。本篇着重于Qt多线程的总结与实现。 跟C++11中很像的是，Qt中使用QThread来管理线程，一个QThread对象管理一个线程，在使用上有很多跟C++11中相似的地方，但更多的是Qt中独有的内容。另外，QThread对象也有消息循环exec()函数，即每个...
多线程中的Join
柯基的博客
09-16 2649
线程中join(强制执行)：当前线程执行完毕之后，才会执行后面程序，其他线程阻塞； 实例： public class ThreadJoin implements Runnable{ @Override public void run() { for (int i = 1; i < 1000; i++) { System.out.println("Join..."+i+"运行中"); } } public stat
Python多线程QThread的使用
junfoot的博客
04-21 6543
在使用pyQt5开发GUI界面是，我们通常会使用到多线程，一般采用pyQt5自带的QThread模块。 from PyQt5.QtCore import QThread, pyqtSignal # 创建线程1的类 class ThreadOne(QThread): trigger = pyqtSignal(data_type) # 此处输入待传送数据类型 def __init__(self): super().__init__() def run(self)
量化之路——QThread的坑，无法加载Thread模块
ruoruodetouzizhe的博客
10-03 1564
from PyQt5.QtCore import * from PyQt5.QtGui import * from PyQt5.QtWidgets import * from PyQt5 import QtCore, QtGui, QtWidgets 用上面的引入即可。。
Qt5 QThread线程 id，pyqt多线程4种实现方式
jacke121的专栏
01-22 4462
Qt5 QThread线程 id，pyqt多线程4种实现方式 版权声明：版权没有，转载随意 https://blog.csdn.net/MAOZEXIJR/article/details/80983337 一、QThread 1、继承QObject # -*- coding: utf-8 -*- from PyQt5.QtCore import * class MyWorker(QObjec...
PyQt5之QThread线程模块
╮(╯_╰)╭ Don't expect me to reply to you in time
07-10 3264
一、QThread1、继承QObject# -*- coding: utf-8 -*- from PyQt5.QtCore import * class MyWorker(QObject): def __init__(self): super(MyWorker, self).__init__() def doWork(self): # do s...
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中QT线程使用方法
最新发布
05-09
在Qt中，线程是通过QThread类实现的。要使用线程，您可以通过以下步骤操作： 1. 创建一个继承自QThread的子类，并重写其run()方法，该方法将在新线程中执行。 2. 在子类的构造函数中初始化线程，并将其设置为自动...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值