Qt - 进程/线程

已于 2023-05-20 20:33:47 修改
阅读量158 收藏
点赞数
分类专栏： qt 文章标签： qt
于 2023-03-09 22:40:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L_fengzifei/article/details/129429692
版权

Qt - 进程/线程

进程

多进程创建

在一个应用程序中启动另一个应用程序

/* widget.h */
#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QProcess>

QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

private slots:
    void on_pushButton_clicked();

private:
    Ui::Widget *ui;
    QProcess *my_process;
};
#endif // WIDGET_H


/* widget.cpp */

#include "widget.h"
#include "ui_widget.h"
//#include <QProcess>
#include <QDebug>

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

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


void Widget::on_pushButton_clicked()
{
    // 启动另一个程序
    my_process->start("f:/Qt/6.2.4/mingw_64/bin/assistant.exe");
    // 阻塞主进程，只能运行my_process进程
    my_process->waitForFinished();

    // 进程之间的数据传输与共享 IPC 任务间的通信与同步
}

进程间通讯与同步 - 共享内存

写

/* widget.h */
#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QSharedMemory>

QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

private slots:
    void on_pushButton_clicked();

private:
    Ui::Widget *ui;

    QSharedMemory memShared; // 创建共享内存对象
};
#endif // WIDGET_H


/* widget.cpp */
#include "widget.h"
#include "ui_widget.h"

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

    /*
        键值：系统底层对该共享内存的唯一的标记
    */
    memShared.setKey("my_shared_mem");
}

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


void Widget::on_pushButton_clicked()
{
    // 判断该共享内存是否被绑定到其他的进程当中
    if(memShared.isAttached())
    {
        // 将该共享内存解除绑定
        memShared.detach();
    }

    // 创建一个共享内存
    // 设置该共享内存的读写模式
    if (!memShared.create(100,QSharedMemory::ReadWrite))
    {
        qDebug()<<"ERROR: create shared memory failed";
        return ;
    }

    // 共享资源的排他性，也就是加锁解锁机制

    // 对共享内存加锁，表示该共享内存只有该进程可以使用
    memShared.lock();

    // memShared 是共享内存类的对象，并不是该共享内存的地址
    // memShared.data() 才是该共享内存的地址，返回一个指针
    // 对于QByteArray 类对象，byteArray.data() 返回一个指向该字节组的一个指针
    QByteArray byteArray=ui->lineEdit->text().toLatin1();
    // qMin 取二者中的较少值
    memcpy(memShared.data(),byteArray.data(),(size_t)qMin(byteArray.size(),memShared.size()));

    // 对共享内存解锁
    memShared.unlock();


}

读

/* widget.h */
#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QSharedMemory>

QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

private slots:
    void on_pushButton_clicked();

private:
    Ui::Widget *ui;
    QSharedMemory memShared;
};
#endif // WIDGET_H


/* widget.cpp */
#include "widget.h"
#include "ui_widget.h"

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

    // 用于进程之间通信的共享内存的键值必须是一样的
    memShared.setKey("my_shared_mem");
}

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


void Widget::on_pushButton_clicked()
{
    // 将该共享内存进行绑定
    // 要读取该共享内存中的数据，必须是已经绑定上的
    if (!memShared.attach())
    {
        qDebug()<<"ERROR: 绑定内存失败";
        return ;
    }

    // 加锁
    memShared.lock();

    // 读取共享内存
//    QByteArray byteArray;
    memcpy(byteArray.data(),memShared.data(),(size_t)qMin(byteArray.size(),memShared.size()));
//    memcpy(byteArray.data(),memShared.data(),(size_t)memShared.size());

//    qDebug()<<byteArray;
//    ui->label->setText(byteArray);

    // version2
    char *arr=new char[memShared.size()];
    memcpy(arr,memShared.data(),(size_t)memShared.size());
    ui->label->setText(QString(arr));

    // 解锁
    memShared.unlock();

}

线程

多线程就要自己从QThread派生一个类
所有的线程都是从类中的run函数开始的，一般所有的实现都是在run中实现
线程先start 然后start自动调用run函数

函数run一般是一个无限循环，可以在函数run里调用函数exit()或quit()结束线程的时效件循环，或是在主线程里调用函数terminat()强制结束线程

QThread继承自QObject，started信号在线程开始运行之前，也就是在函数run被调用之前被发射；finshed信号在线程即将结束时发射

多线程独立并发

自定义线程类

/* myThread.h */
#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QObject>
#include <QThread>

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


signals:

protected:
    void run(); // 线程从run函数开始运行的, run函数的调用靠的是QThread类里的start函数，启动线程先调用start函数，然后start函数自动关联run函数

private:
    bool isStop;
};

class MyThreadSec:public QThread
{
    Q_OBJECT

public:
    explicit MyThreadSec(QObject *parent=nullptr);
    void threadStop();
signals:

protected:
    void run();

private:
    bool isStop;
};

#endif // MYTHREAD_H

/* myThread.cpp */

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

MyThread::MyThread(QObject *parent)
    : QThread(parent)
{
    isStop=false;
}

void MyThread::run()
{
    int i=0;
    while (!isStop)
    {
        qDebug()<<"myThread i:"<<i;

        // 线程阻塞(延时)
        this->msleep(1000); // 以毫秒为单位
        i+=2;
    }
    if (isStop)
    {
        isStop=false;
    }
}

void MyThread::threadStop()
{
    isStop=true;
}

MyThreadSec::MyThreadSec(QObject *parent)
    : QThread(parent)
{
    isStop=false;
}

void MyThreadSec::run()
{
    int i=1;
    while (!isStop)
    {
        qDebug()<<"myThread i:"<<i;

        // 线程阻塞(延时)
        this->msleep(1000); // 以毫秒为单位
        i+=2;
    }
    if (isStop)
    {
        isStop=false;
    }
}

void MyThreadSec::threadStop()
{
    isStop=true;
}

widget类

/* 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);
    ~Widget();

private slots:
    void on_pushButton_clicked();

    void on_pushButton_3_clicked();

    void on_pushButton_2_clicked();

    void on_pushButton_4_clicked();

private:
    Ui::Widget *ui;
    MyThread *myThread;
    MyThreadSec *myThreadSec;
};
#endif // WIDGET_H

/* widget.cpp */

#include "widget.h"
#include "ui_widget.h"

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

    // 创建线程
    myThread=new MyThread(this);
    ui->pushButton_3->setEnabled(false); // 停止线程按钮默认不能被点击

    // 创建第二个线程
    myThreadSec=new MyThreadSec(this);
    ui->pushButton_4->setEnabled(false);
}

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

void Widget::on_pushButton_clicked()
{
    // 启动线程，然后自动调用run函数
    myThread->start();
    ui->pushButton->setEnabled(false); // 启动线程按钮不能被点击
    ui->pushButton_3->setEnabled(true); // 停止线程按钮能被点击
}

void Widget::on_pushButton_3_clicked()
{
    // 判断线程是否正在运行
    if (myThread->isRunning())
    {
        // 设置停止标志
        myThread->threadStop();
        ui->pushButton->setEnabled(true);
        ui->pushButton_3->setEnabled(false);
    }
}


void Widget::on_pushButton_2_clicked()
{
    myThreadSec->start();
    ui->pushButton_2->setEnabled(false);
    ui->pushButton_4->setEnabled(true);
}



void Widget::on_pushButton_4_clicked()
{
    if (myThreadSec->isRunning())
    {
        myThreadSec->threadStop();
        ui->pushButton_2->setEnabled(true);
        ui->pushButton_4->setEnabled(false);
    }
}

信号量

自定义线程类

/* myThread.h */

#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QObject>
#include <QThread>
#include <QSemaphore>

class Producer : public QThread
{
    Q_OBJECT
public:
    explicit Producer(QObject *parent = nullptr);
    void threadStop();
signals:

protected:
    void run();

private:
    bool isStop;
};

class Consumer:public QThread
{
    Q_OBJECT
public:
    explicit Consumer(QObject *parent=nullptr);
    void threadStop();

protected:
    void run();

private:
    bool isStop;
};

#endif // MYTHREAD_H


/* myThread.cpp */
#include "mythread.h"
#include <QDebug>

const int size=10;
unsigned int buffer[size];

QSemaphore usedSem(0); // 初始值为0 可以设置为0，取出内存空间中的数
QSemaphore nousedSem(size); // 初始值为10 表示内存空间中还没有多少个没有被填充，也就是内存空间为空（还有多少位置为空）

Producer::Producer(QObject *parent)
    : QThread(parent)
{
    isStop=false;
}

void Producer::run()
{
    static int procuder_i=0;
    while (!isStop)
    {
        qDebug()<<"producer waiting to produce...";
        // 获得信号量, 对应的信号量nousedSem 自动-1 ,是否大于=0 如果小于0则线程阻塞
        // 判断信号量是否>0 ,<=0则阻塞
        nousedSem.acquire();

        // 如果没有被阻塞，则继续执行，就向空的位置填充一个，表示生产一个
        buffer[procuder_i]=procuder_i;
        msleep(1000); // 每隔一秒钟生产一个
        qDebug()<<"wirte to shared buffer:"<<procuder_i;

        // 只要产生了一个，就可以有一个能被消费，则增加消费者信号量（初始为0）
        // 释放一个信号量, 对应的信号量usedSem 自动+1
        usedSem.release();

        procuder_i++;
        if (procuder_i==size) // 说明生产出来10个
        {
            procuder_i=0;
        }
    }

    isStop=false;
}

void Producer::threadStop()
{
    isStop=true;
}

Consumer::Consumer(QObject *parent)
{
    isStop=false;
}

void Consumer::run()
{
    static int consumer_i=0;
    while (!isStop)
    {
        // 获得信号量 自动-1，将要消费
        usedSem.acquire(); // 阻塞执行，消费者获得权限
        qDebug()<<buffer[consumer_i];

        nousedSem.release(); // 生产者获得权限（消费者消耗掉一个，生产者就可以多生产一个）

        consumer_i++;
        if (consumer_i==size)
        {
            consumer_i=0;
        }
    }

    isStop=false;
}

void Consumer::threadStop()
{
    isStop=true;
}

widget类

/* widget.h */

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QThread>
#include <QSemaphore> // 信号量头文件

#include "mythread.h"

QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

private slots:
    void on_pushButton_clicked();

    void on_pushButton_2_clicked();

    void on_pushButton_3_clicked();

    void on_pushButton_4_clicked();

private:
    Ui::Widget *ui;
    Producer *producerThread; // 生产者线程
    Consumer *consumerThread; // 消费者线程
};
#endif // WIDGET_H


/* widget.cpp */

#include "widget.h"
#include "ui_widget.h"

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

    /*
        信号量：
            获得信号的 信号量>=0 线程可以运行；<= 线程只能阻塞

        实现两个信号量
            生产信号量 表示生产多少
            消费信号量 表示消耗多少
    */

    // 创建两个线程
    this->producerThread=new Producer(this);
    this->consumerThread=new Consumer(this);
    ui->pushButton_2->setEnabled(false);
    ui->pushButton_4->setEnabled(false);
}

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


void Widget::on_pushButton_clicked()
{
    producerThread->start();
    ui->pushButton->setEnabled(false);
    ui->pushButton_2->setEnabled(true);
}


void Widget::on_pushButton_2_clicked()
{
    producerThread->threadStop();
    ui->pushButton->setEnabled(true);
    ui->pushButton_2->setEnabled(false);
}


void Widget::on_pushButton_3_clicked()
{
    consumerThread->start();
    ui->pushButton_3->setEnabled(false);
    ui->pushButton_4->setEnabled(true);
}


void Widget::on_pushButton_4_clicked()
{
    consumerThread->threadStop();
    ui->pushButton_3->setEnabled(true);
    ui->pushButton_4->setEnabled(false);
}
aoaoGofei
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程里使用数据库——QtWidgets
xiaopei_yan的博客
08-10 1401
之前没怎么在项目中使用数据库，对数据库这块只了解一点皮毛，只能说能用。这次涉及了在多线程中使用数据库，看了看源码，和吸取了网上的一些经验，整理封装了一下。
QT：实现一个简单的多线程，动态创建
weixin_49223760的博客
07-06 636
在QT中如何实现一个简单的多线程呢
Qt多线程简单实现Widget
Roninzhz的博客
05-09 1354
threaddlg.h #ifndef THREADDLG_H #define THREADDLG_H #define MAXSIZE 1 //定义线程数目 #include <QDialog> #include <QPushButton> #include "workthread.h" QT_BEGIN_NAMESPACE namespace Ui { class threaddlg; } QT_END_NAMESPACE class threaddlg : public
在Qt中，使用多个子线程作为服务端连入主线程服务端，并在子线程中使用Qwidge窗口
iLinYe的博客
10-13 166
没什么难点，主要就是在如果用常规写法直接在子线程里面直接new出来一个新的Qwidget的话，show大概率是会报错的，因为只允许一个gui线程，这个时候找了一些资料，要在子线程里面做一些处理（1，使用move将子线程移动到主线程中，2，使用eventloop事件循环来显示这个Qwidget才行），还有就是如何判断是哪个客户端发来的消息，这个实在不会，也没有找到一些资料，没办法，使用土办法，判断客户端发来的消息来找到是哪个客户端。线程类.cpp Client.cpp。线程类代码：Client.h。
QT中多线程实现的三种方式
qq_65072319的博客
10-18 783
在Qt中经常会遇到耗时操作，需要并发执行，建立线程的主要目的就是为了用线程来处理那些耗时的后台操作 1、继承QThread 重写run方法 2、继承QObject，movetothread 3、使用QT的 QThreadPool 类， 继承QRunnable，重写run函数
用QT实现的进程线程，线程同步和线程互斥程序
01-31
用QT实现的进程线程，线程同步和线程互斥程序。所有的实验效果都在文章里。
QT/C++多线程练习:单生产者多消费者(源码)
09-09
使用linux qt打开文件夹下的.pro文件即可。 涉及 线程创建与退出、线程暂停、父子线程之前以及兄弟线程之间的参数和信号传递、多线程的以及多线程的管理。要求是练习的demo对于以上的点只要涉及基础即可。 主线程...
Qt线程之间通信、线程和进程之间通信实例
05-25
Qt线程之间通信、线程和进程之间通信实例，简单易懂
Qt 使用多线程QThread实现进度条
01-12
Qt 使用多线程QThread实现进度条
QT Socket编程 多线程服务器
01-14
QT Socket 多线程
QT 语言的学习 day09 进程 和 线程
she666666的博客
09-27 357
进程 和 线程
QT/C++——文件和进程线程编程
qq_52479948的博客
01-31 1218
QT/C++——文件和进程线程编程
Qt进程和线程QProcess和QThread
qq_45698138的博客
08-10 2175
/一个继承于QObject类的一个自定义类//自定义槽函数work(){while(1){}}//在主线程中创建一个普通QThread类的对象mth//在主线程中创建一个自定义类thread_object 的对象work//将w的实现移入线程mth的作用范围//用信号关联w里面想要执行的任务//在主线程中声明一个信号start_th();signals://关联这个信号的槽函数为workwork();//开启线程每一个QT程序都存在一个默认的线程池。......
QT实现线程操作
new9232的博客
12-26 1635
1、第一种方法 第一种方法是QT4.8之前的写法，需要重写一个类，继承于QThread类。 1.1、自己实现一个子线程类myThread，并继承于QThread类。 1.2、重写子线程类myThread中的虚函数run()。 1.3、在主线程Widget中定义子线程类对象。 1.4、在主线程Widget中连接信号槽，实现子线程于主线程之前通信。 1.5、主线程Widget中使用子线程的start()方法启动子线程。 项目结构 主线程代码 widget.h #ifndef WID
QT中的线程
weixin_49606782的博客
09-23 2608
主线程(又称 GUI线程),负责监控窗口上的任何事件,一旦发现事件,立马处理.GUI线程只负责 UI刷新.但是有时候,任务很耗时,GUI进程会卡住,UI无响应这个时候创建一个新的子线程,负责处理 耗时的任务,注意：非GUI线程禁止访问 界面上任何元素.
QT 创建线程的三种方法
热门推荐
wanglei_11的博客
12-26 1万+
QT 创建线程的三种方法
12 Qt4及Qt5的多线程编程
王木木
04-14 1647
一个可重入的类，指的是它的成员函数可以被多个线程安全地调用，只要每个线程使用这个类的不同的对象。而一个线程安全的类，指的是它的成员函数能够被多线程安全地调用，即使所有的线程都使用该类的同一个实例也没有关系。 QObject是可重入的。它的大多数非GUI子类，例如：QTimer、QTcpSocket、QUdpSocket和QProcess，也都是可重入的，这使得在多线程中同时使用这些类成为可能...
QT多线程的使用
hw5230的博客
02-27 514
Qt中提供了对于线程的支持，它提供了一些独立于平台的线程类，要进行多线程方法，可以有两种方式。
Qt知识回顾（十六）——进程和线程
AAAA202012的博客
11-22 1922
进程   设计应用程序时，有时不希望将一个不太相关的功能集成到程序中，或者是因为该功能与当前设计的应用程序联系不大，或者是因 运行一个进程   Qt的QProcess类用来启动一个外部程序并与其进行通信。要启动一个进程，可以使用start()函数，然后将程序名称和运行这个程序所要使用的命令行参数作为该函数的参数。执行完start()函数后，QProcess进入Starting状态，当程序已经运行后，QProcess就会进入Running状态并发射started()信号，当进程退出后，QProcess重新进入
qt下多进程线程的使用
最新发布
10-24
在QT中，可以使用多进程和多线程来实现并发编程。多进程可以使用QProcess类来实现，该类可以启动一个新的进程，并与其进行通信。多线程可以使用Qt提供的QThread类来实现，也可以使用C++标准库中的线程库来实现。在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值