Qt 进程间通信

已于 2023-02-25 10:35:06 修改
阅读量5.9k 收藏 55
点赞数 4
分类专栏： Qt网络和线程 文章标签： qt
于 2023-02-24 17:23:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45303986/article/details/129186490
版权

Qt进程间通信的方法：

  1. TCP/IP
  2. Local Server/Socket
  3. 共享内存
  4. D-Bus （Unix库）
  5. QProcess
  6. 会话管理

TCP/IP ：

使用套接字的方式，进行通信（之前介绍了，这里就不介绍了）。

Local Server/Socket 

跨平台Qt网络模块提供的类使本地网络编程变得可移植且简单。它提供了QLocalServer和QLocalSocket类，允许在本地设置中进行类似网络的通信。它们的 TCP 对应项可以用作直接替代品，以使跨网络通信工作。（使用方法和TCP相似） 

QLocalServer ：

使用方法：

  1. listen（）监听指定密钥上的传入连接
  2. 有客户端连接时，会发出newConnection（）信号
  3. 使用nextPengingConnection（）获取连接的QLocalSocket
  4. close（）关闭监听

listen（QString）

监听
close（）关闭监听
errorString（）报告的当前错误的人类可读消息
fullServerName（）返回服务器正在侦听的完整路径
isListrening()服务器正在侦听传入连接,true,否则为false
maxPendingConnection()返回挂起的接受连接的最大数目。默认值为 30
nextPengingConnection()将一个挂起的连接作为连接的 QLocalServer 对象返回
serverName（）则返回服务器名称
socketOption（）返回在套接字上设置的套接字选项
waitForNewConnection（int）堵塞多少毫秒或直到传入连接可用

QLocalSocket

在Windows上是一个命名管道，在Unix上是一个本地套接字。

QLocalSocket 设计用于事件循环，但也可以在没有事件循环的情况下使用它。在这种情况下，您必须使用 waitForConnected（）、waitForReadyRead（）、waitForBytesWrite（） 和 waitForDisconnected（），它们会阻止操作完成或超时到期。

使用方法：

  1. 使用connectToServer（）与服务器简建立连接。
  2. 可以使用readData（）读取数据，writeData（）写入数据
  3. abort（）断开连接
  4. close（），或disconnectFromServer()关闭套接字
connectToServer（）连接服务器
bytesAvailable（）获取数据大小
error（）返回上次发生的错误类型
flush（）此函数尽可能多地从内部写入缓冲区写入套接字，而不会阻塞。如果写入了任何数据返回true
fullServerName（）返回套接字连接到的服务器路径
isVaild（）判断套接字是否可用
readData（）读取数据
writeData（）写入数据
setReadBufferSize()设置内部缓冲区大小
waitForConnected（）等待连接
waitForReadyRead（）等待读取
waitForBytesWrite（）等待写入
waitForDisconnected（）等待断开

 LoaclServer的搭建：

pro文件中添加：

QT  +network

在ui界面中添加：

QTextEdit 、QPushButton 和QLineEdit

.h文件：

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include<QLocalServer>
#include<QLocalSocket>
#include<QMessageBox>
#include<QDataStream>

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;
    QLocalServer *localserver;//服务端
    QLocalSocket*localsocket=nullptr;//套接字

};
#endif // WIDGET_H

.cpp文件：

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

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    setWindowTitle("服务器端");
    localserver=new QLocalServer(this);
    localserver->listen("Good People");//Good People作为连接字符
    connect(localserver,&QLocalServer::newConnection,[=]()
    {
        localsocket=localserver->nextPendingConnection();//获取连接的套接字
        connect(localsocket,&QLocalSocket::readyRead,[=]()//如果有可读数据的话
        {
            QByteArray block;
            block=localsocket->readAll();
            QString S=block.data();
            ui->textEdit->append(QString("客户端：%1").arg(S));
        });

    });
}

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


void Widget::on_pushButton_clicked()//发送数据
{
    if(ui->lineEdit->text().isEmpty())
    {
        QMessageBox::information(this,"提示信息","请输入内容",QMessageBox::Ok);
        return;
    }
    ui->textEdit->setText(QString("服务器端：%1").arg(ui->lineEdit->text()));//设置内容
    if(localsocket->isValid())
    {
        QString S=ui->lineEdit->text();
        localsocket->write(S.toUtf8());//发送消息
    }

}

LocalSocket客户端的搭建：

pro文件中添加：

QT +=network

ui界面中添加：

.h文件：

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include<QLocalSocket>
#include<QMessageBox>
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();

private:
    Ui::Widget *ui;
    QLocalSocket * localsocket;//套接字
};
#endif // WIDGET_H

.cpp文件：

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

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    localsocket=new QLocalSocket(this);
    setWindowTitle("客户端");
    connect(localsocket,&QLocalSocket::readyRead,[=]()
    {
        QByteArray block;
        block=localsocket->readAll();//读取信息
        ui->textEdit->append(QString("服务器：%1").arg(block.data()));//聊天框添加信息
    });

}

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


void Widget::on_pushButton_clicked()//连接
{
    localsocket->abort();//先断开
    localsocket->connectToServer("Good People");//连接
}

void Widget::on_pushButton_2_clicked()//发送
{
    if(ui->lineEdit->text().isEmpty())
    {
        QMessageBox::information(this,"提示信息","请输入内容。",QMessageBox::Ok);
        return;
    }
    if(localsocket->isValid())
    {
        localsocket->write(ui->lineEdit->text().toUtf8());
        ui->textEdit->append(QString("客户端：%1").arg(ui->lineEdit->text()));
    }


}

运行效果：

 共享内存：

QSharedMemory

QSharedMemory 提供通过多个线程和进程对共享内存段的访问。它还为单个线程或进程提供了一种锁定内存以进行独占访问的方法。

使用此类时，请注意以下平台差异：

  • Windows：QSharedMemory 不“拥有”共享内存段。当将 QSharedMemory 实例附加到特定共享内存段的所有线程或进程都销毁其 QSharedMemory 实例或退出时，Windows 内核会自动释放共享内存段。
  • Unix：QSharedMemory“拥有”共享内存段。当将 QSharedMemory 实例附加到特定共享内存段的最后一个线程或进程通过销毁其 QSharedMemory 实例与该段分离时，Unix 内核将释放共享内存段。但是，如果在未运行 QSharedMemory 析构函数的情况下最后一个线程或进程崩溃，则共享内存段将在崩溃中幸存下来。
  • HP-UX：每个进程只允许一个附加到共享内存段。这意味着 QSharedMemory 不应在 HP-UX 中同一进程中的多个线程中使用。

注意：由于是共享内存，所以使用共享内存之前使用lock（）锁定共享内存，使用完后需要解锁。当 QSharedMemory 的最后一个实例从共享内存段分离时，QSharedMemory 会自动销毁该段，并且不会保留对该段的引用。

常用函数：

setKey（QString）设置此共享内存对象的平台独立键
setNativeKey()设置此共享内存对象的特定于平台的本机密钥。如果 key 与当前本机键相同，则函数返回而不执行任何操作。
lock()对共享内存上锁
unlock()对共享内存解锁
size()返回附加的共享内存段的大小。如果未连接共享内存段，则返回 0。
isAttached()如果此进程连接到共享内存段返回true
errorString（）错误信息
detach（）将进程与共享内存段分离。如果这是附加到共享内存段的最后一个进程，则系统将释放共享内存段，即内容被销毁。
data（）返回指向共享内存段内容的指针（如果已连接）
create（）使用传递给构造函数的键创建大小为字节的共享内存段
constData（）返回指向共享内存段内容的 const 指针（如果已连接）
attach（）尝试将进程附加到由传递给构造函数的键或对 setKey（） 或 setNativeKey（） 的调用标识的共享内存段。访问模式默认为读写

QSharedMemory：：AccessMode

QSharedMemory::ReadOnly共享内存段是只读的。不允许写入共享内存段。尝试写入使用 ReadOnly 创建的共享内存段会导致程序中止。
QSharedMemory::ReadWrite读取和写入共享内存段都是允许的。

基本使用流程：

 发送内容到共享内存

  1. 设置一个标识  setKey（）；
  2. 使用isAttached（）判断进程是否与共享内存相连
  3. 使用detach（）断开连接
  4. create（size）创建共享内存
  5. 上锁
  6. 将数据写入共享内存
  7. 解锁

从共享内存中读取数据：

  1. attach（）连接到共享内存
  2. 上锁
  3. 读取数据
  4. 解锁

例子：写入和读取数据

    QSharedMemory memory;创建对象
    memory.setKey("1000");//设置标识

    //写入数据
    if(memory.isAttached())//已经连接的话
    {
        memory.detach();//断开连接
    }
    QString Str="SharedMemory";

    QBuffer buffer;
    buffer.open(QBuffer::ReadWrite);
    QDataStream S(&buffer);
    S<<Str;//将数据写到缓存中
    memory.create(buffer.size());//创建共享内存
    memory.lock();//上锁
    char * M=(char *)memory.data();//获取memory的指针
    const char *N=buffer.data().data();//获取缓存的指针
    memcpy(M,N,buffer.size());//把数据复制到共享内存中
    memory.unlock();//解锁

    //读取数据
    memory.attach();//连接共享内存
    QBuffer buffer1;
    QDataStream in(&buffer);
    QString Str1;

    memory.lock();//上锁
    buffer.setData((char*)memory.constData(),memory.size());//存入数据
    buffer.open(QBuffer::ReadOnly);//只读模式
    in>>Str1;//读取数据
    memory.unlock();//解锁

    memory.detach();//断开连接
    qDebug()<<Str1;

使用共享内存实现两个进程的聊天：

ui界面：

.h文件：

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include<QSharedMemory>
#include<QBuffer>
#include<QMessageBox>
#include<QDataStream>
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();

private:
    Ui::Widget *ui;
    QSharedMemory sharedmemory;//共享内存
};
#endif // WIDGET_H

.cpp文件：

#include "widget.h"
#include "ui_widget.h"
#include<QDebug>
Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    sharedmemory.setKey("GG");//设置标识
}

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


void Widget::on_pushButton_clicked()//读取数据
{
    if(!sharedmemory.attach())
    {
        QMessageBox::information(this,"提示信息","连接共享内存失败",QMessageBox::Ok);
        return;
    }
    QBuffer buffer;
    QString S1;
    QDataStream in(&buffer);
    sharedmemory.lock();
    buffer.setData((char *)sharedmemory.constData(),sharedmemory.size());//设置数据
    buffer.open(QBuffer::ReadOnly);
    in>>S1;//读取数据
    sharedmemory.unlock();//解锁
    sharedmemory.detach();//断开连接
    ui->textEdit->append(QString("他人：%1").arg(S1));
}

void Widget::on_pushButton_2_clicked()//发送数据
{
    if(sharedmemory.isAttached())//内存和进程连接
    {
       if(sharedmemory.detach())//断开连接
       {
           QMessageBox::information(this,"提示信息","已断开连接");
       }
       else
       {
           QMessageBox::information(this,"提示信息","断开连接失败");
           return;
       }
    }
    if(ui->lineEdit->text().isEmpty())
    {
        QMessageBox::information(this,"提示信息","内容不能为空。",QMessageBox::Ok);
    }
    QBuffer buffer;
    buffer.open(QBuffer::ReadWrite);
    QDataStream out(&buffer);
    QString Str=ui->lineEdit->text();
    out<<Str;//把内容写入缓存区
    int size=buffer.size();
    if(!sharedmemory.create(size))
    {
        QMessageBox::information(this,"提示信息","内存创建失败",QMessageBox::Ok);
        return;
    }
    sharedmemory.lock();
    const char * Buff=buffer.data().data();//获取buffer的指针
    char *Sha=(char *)sharedmemory.data();//获取共享内存的指针
    memcpy(Sha,Buff,qMin(sharedmemory.size(),size));
    sharedmemory.unlock();//解锁
    ui->textEdit->append(QString("本人：%1").arg(ui->lineEdit->text()));//显示信息
}

void Widget::on_pushButton_3_clicked()//断开连接
{
    if(sharedmemory.detach())//断开连接
    {
        QMessageBox::information(this,"提示信息","已断开连接");
    }
}

main函数：

#include "widget.h"

#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Widget w1;
    w1.setWindowTitle("widget1");
    w1.show();//进程1
    Widget w2;
    w2.setWindowTitle("widget2");
    w2.show();//进程2
    return a.exec();
}

这里解释一下为什么要有断开连接的按钮：

经过多次测试发现 ：

A端发完数据，B端接收数据后，A端需要主动断开连接后B端才能正常发送数据。

（懂的大佬请在评论区解释一下）

效果：

widget2 发送信息给widget1

 记住发送端需要主动断开连接：

widget1 发送信息给 widget2

 QProcess

参考文章：关于Qt的QProcess进程间双向通信_qprocess进程间通信_weixin_46424582的博客-CSDN博客

QProcess进程间通信：

 主线程构建思路：

  • 发送数据到子进程：使用write（）函数
  • 读取子进程发送的数据数据：监听readReadyStandardOutput()信号

创建一个项目：

ui界面中添加以下控件： textEdit   pushButton  lineEdit

.h文件：

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include<QProcess>
#include<QMessageBox>
#include<QDebug>
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();
private:
    Ui::Widget *ui;
    QProcess *process;
};
#endif // WIDGET_H

.cpp文件：

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

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    setWindowTitle("主进程");
    process=new QProcess;
    connect(process,&QProcess::readyReadStandardOutput,[=]()//读取信息
    {
        QString S=process->readAllStandardOutput().data();
        ui->textEdit->append(QString("子线程：%1").arg(S));
    });

}

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

void Widget::on_pushButton_clicked()//打开子进程
{
    //子线程的开启
    process->start("D:/Qt_data/build-QProcess_text1-Desktop_Qt_5_9_9_MinGW_32bit-Debug/debug/QProcess_text1.exe");

}

void Widget::on_pushButton_2_clicked()//发送数据
{

    if(ui->lineEdit->text().isEmpty())
    {
        QMessageBox::information(this,"提示信息","输入框不能为空。",QMessageBox::Ok);
        return;
    }
    if(process->Running)
    {
        QString S=ui->lineEdit->text();//获取lineEdit中的内容
        process->write(S.toStdString().c_str());//写入数据
        ui->textEdit->append("父线程："+S);//在聊天框显示内容
    }
    return;

}

子线程的构建思路：

  • 发送数据到父线程：使用文件打开 stdout，然后把数据写入stdout中
  • 获取父线程发送过来的数据：
    • linux中：使用QSocketNotifier 监听 stdin文件，当改文件有变化是，读取信息
    • Windows中：需要开启一个线程来管理stdin的文件变化，这个需要使用Windows API函数

这里介绍Windows中的子线程构建：

创建一个项目：

在pro文件中添加：

QT +=concurrent

ui界面中添加：

 .h文件：

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include<QFile>
#include<QSocketNotifier>
#include<QBuffer>
#include<QMessageBox>
#include<QFuture>
#include<QtConcurrent>
#include<QIODevice>
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 readStdin();//读取数据

private:
    Ui::Widget *ui;
    QFile file;
signals:
    void sig_log(QString S);//显示数据
    void sig_receivedCommand(QString S);//显示数据
};
#endif // WIDGET_H

.cpp文件：

#include "widget.h"
#include "ui_widget.h"
#include<iostream>
#include<windows.h>
#include<io.h>
#include<fcntl.h>
#include<QSocketNotifier>
Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    setWindowTitle("子进程");

    QFuture<void> fu=QtConcurrent::run(this,&Widget::readStdin);//开启一个线程
    connect(this,&Widget::sig_receivedCommand,this,[&](QString s)
    {
        ui->textEdit->append("父线程："+s);
    });
    connect(this,&Widget::sig_log,this,[=](QString s)
    {
        ui->textEdit->append("父线程："+s);
    });

}

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


void Widget::readStdin()//读取数据
{
    bool ok=true;
    char chbuf[1024];//缓存
    DWORD dwRead;//32位无符号整数
    HANDLE hStdinDup;//HANDLE 句柄类型

    const HANDLE hStdin=GetStdHandle(STD_INPUT_HANDLE);//GetStdHandle获取标准输入的句柄
    if(hStdin==INVALID_HANDLE_VALUE)//为无效句柄的话
        return;
    DuplicateHandle(GetCurrentProcess(),hStdin,
                    GetCurrentProcess(),&hStdinDup,0,false,DUPLICATE_SAME_ACCESS);//创建一个新句柄
    CloseHandle(hStdin);//关闭旧句柄
    while(ok)
    {
        ok=ReadFile(hStdinDup,chbuf,sizeof(chbuf),&dwRead,NULL);//读取hstdinDup句柄文件中的数据
        emit sig_log(QLatin1String("ok is:")+QString::number(ok));
        if(ok &&dwRead!=0)
        {
            emit sig_receivedCommand(QString::fromUtf8(chbuf,dwRead));//读取数据
        }
    }

}

void Widget::on_pushButton_clicked()//发送数据
{
    if(ui->lineEdit->text().isEmpty())
    {
        QMessageBox::information(this,"提示信息","输入框不能为空。",QMessageBox::Ok);
        return;
    }
    QFile fileout;
    if(fileout.open(stdout,QIODevice::WriteOnly))
    {
        QString S=ui->lineEdit->text();
        fileout.write(S.toStdString().c_str());
        ui->textEdit->append("子线程："+S);
        fileout.close();//关闭文件
    }

}

运行效果：

旷工锁
关注
  • 4
    点赞
  • 踩
  • 55
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Qt进程间通信与同步示例
04-29
Qt进程间通信与同步示例，通过QFile内存映射文件来共享内存达到进程间通信的效果。同时利用QSystemSemaphore 来实现进程同步
Qt之进程通信-IPC（QLocalServer，QLocalSocket 含源码+注释）
lw的博客
08-28 1521
如下，分别在各个界面的关键字控件中填入key，依次连接。 如下，简单演示了server与全部、指定socket通信及接收socket发送的数据。 如下，演示了单独断开一个及断开全部的操作，其中断开操作是由server发送数据通知socket断开，server这边则等待断开返回。 如下演示了socket程序主动断开的操作 如下，演示了server停止监听后仍可以与已经连接过的socket的通信的效果。 以及在个人理解中的第2点也存在一些疑问 四、源码 CMainWindowServer CMainWin
QT 进程间通信——共享内存-附件资源
03-05
QT 进程间通信——共享内存-附件资源
QT之进程和进程间通信（IPC）
01-03
进程是操作系统的基础之一。一个进程可以认为是一个正在执行的程序。我们可以把进程当做计算机运行时的一个基础单位。关于进程的讨论已经超出了本章的范畴，现在我们假定你是了解这个概念的。 在 Qt 中，我们使用QProcess来表示一个进程。这个类可以允许我们的应用程序开启一个新的外部程序，并且与这个程序进行通讯。下面我们用一个非常简单的例子开始我们本章有关进程的阐述。
ipc.rar_qt进程间通信
09-23
进程间通信是用qt写的东西希望对大家有用啊
Qt ---进程间的通信
m0_75179090的博客
09-14 1806
首先采用了TCP通讯，所有收发命令都做好后，进行测试，当开启相机实时预览的时候，TCP出现了“假死”，即这边发送消息，另一边怎么都没反应，使用wireshark ，抓包发现，一旦发送了实时预览命令开启预览后，后面无论发送什么消息。wireshark 都没有数据包，并且最终信息提示 TCP 出现了问题（图片信息及出现的问题错误代码，现在没有了，期间电脑固态坏了，数据没了），这个错误问题，经搜索引擎最终没能解决（这个问题还是没有探索出来）。就难易程度，使用习惯及速度方面，进程间通讯，TCP无疑是很好的。
QT 进程间通信方式
QtCompany的博客
04-27 1460
进程间RPC调用（Remote Procedure Call, RPC）：QT提供了QDBus类，它基于D-Bus协议，可以为进程之间的方法调用提供远程过程调用支持。这样，一个进程可以通过D-Bus协议调用另一个进程的方法。TCP/IP套接字（TCP/IP Sockets）：QT提供了QTcpSocket和QTcpServer类，可以用于在不同计算机或同一计算机上的不同进程之间建立TCP/IP连接。创建一个命名管道后，进程可以打开该管道并向其写入数据，另一个进程则可以读取这些数据。
Qt之进程间通信（IPC）
weixin_34244102的博客
01-26 844
简述 进程间通信，就是在不同进程之间传播或交换信息。那么不同进程之间存在着什么双方都可以访问的介质呢？进程的用户空间是互相独立的，一般而言是不能互相访问的，唯一的例外是共享内存区。但是，系统空间却是“公共场所”，所以内核显然可以提供这样的条件。除此以外，那就是双方都可以访问的外设了。在这个意义上，两个进程当然也可以通过磁盘上的普通文件...
Qt 之进程间通信（IPC）
thanklife的专栏
06-23 1220
Qt 之进程间通信（IPC） 简述 通信目的 通信方式 Qt进程通信 TCP/IP Shared Memory D-Bus QProcess Session Management 更多参考 QT5软件开发入门到项目实战PDF(配完整示例代码)(持续更新) Qt实现IPC进程间通信-mqueue消息队列 QtDBus总结 原文链接：https://blog.csdn.net/liang19890820/article/details/50589285简述 进程间通信，就是在不同进程之间传播或交换信息。那么不同
Qt进程间通信
MechMaster
04-22 3665
Qt 进程间通信 1. 进程间通信的方法 2. 不同进程间共享内存示例代码
cop.rar_copserv cel f_qt 进程间通信_qt进程间通信
09-19
cop: 利用QCOP在进程间通信的例子，在ＱＴ／Ｘ１１4.2.2版本中编译通过
Qt进程和线程之一：运行一个进程和进程间通信
m0_60259116的博客
03-08 759
Qt进程和线程 进程和进程间通信 （一）
Qt QProcess进程间调用及交互通信，完整示例
最新发布
FreeLikeTheWind的博客
01-09 2228
Qt QProcess进程间调用及交互通信，完整示例
QT实现进程间通信IPC（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
11-11 70
QT实现进程间通信IPC（附完整源码）
Qt之进程间通信（QProcess）
weixin_33860528的博客
01-28 2599
简述 QProcess可以在应用程序内部与其它进程通信，或启动其它应用程序。与在终端机之类的命令输入窗口上使用名称和参数是一样的，可以使用QProcess提供的函数start()启动进程。可以注册QStringList处理进程后的参数。 简述 命令行参数启动 说明 实现 命令行读取 说明 实现 更多参考 ...
Qt 进程和线程：运行一个进程和进程间通信
QtCompany的博客
07-21 511
Qt提供了一个与平台无关的QProcess类，用以对进程的支持。本节讲述了怎样在Qt应用程序中启动一个外部程序进程，以及几种常用的进程间通信方法。设计应用程序时，有时不希望将一个不太相关的功能集成到程序中，或者是因为该功能与当前设计的应用程序联系不大，或者是因为该功能已经可以使用现成的程序很好地实现了，这时就可以在当前的应用程序中调用外部的程序来实现该功能，这就会使用到进程。Qt应用程序可以很容易地启动一个外部应用程序，而且Qt也提供了多种进程间通信的方法。
QT开发（三十五）——QT进程间通信
weixin_34413802的博客
12-05 790
QT开发（三十五）——QT进程间通信Qt 是一个跨平台的应用框架，其进程间通信机制当然可以使用所在平台的进程间通信机制，如在Windows平台上的Message机制、共享内存、文件映射、管道、Socket等。其中，Qt对一些许多平台共有的IPC机制进行了封装。一、TCP/IP其实就是通过网络模块实现的IPC。不过Qt对其进行了封装，并提供了两个层次的API，包...
Qt基础之二十：进程间通信
草上爬的博客
01-08 6591
进程间通信（IPC：Inter-Process Communication），就是在不同进程之间传播或交换信息。那么不同进程之间存在着什么双方都可以访问的介质呢？进程的用户空间是互相独立的，一般而言是不能互相访问的，唯一的例外是共享内存区。但是，系统空间却是“公共场所”，所以内核显然可以提供这样的条件。除此以外，那就是双方都可以访问的外设了。在这个意义上，两个进程当然也可以通过磁盘上的普通文件交换信息，或者通过“注册表”或其它数据库中的某些表项和记录交换信息。
qt 进程间通信 共享内存 调用函数过程
06-08
在 Qt 中，可以使用 QSharedMemory 类实现共享内存，进程间通信的过程包括以下步骤： 1. 创建共享内存区域：在某个进程中创建一个 QSharedMemory 对象，调用 create() 函数创建共享内存区域，指定共享内存的大小和其他属性。 2. 连接共享内存区域：在其他进程中也创建一个 QSharedMemory 对象，调用 attach() 函数连接到已经创建的共享内存区域，获取共享内存的地址。多个进程可以通过同一个 key 值连接到同一块共享内存区域。 3. 在共享内存中进行数据交换：多个进程都可以访问共享内存区域中的数据，可以使用锁机制等方式来确保数据的同步和正确性。在 Qt 中，可以使用 QMutex 等类来实现锁机制。 4. 调用函数：在共享内存中存储的数据通常是一些结构体、类或对象等，可以在一个进程中修改这些数据，然后在另一个进程中调用相应的函数来处理这些数据。在 Qt 中，可以使用 QBuffer、QDataStream 等类来实现数据的序列化和反序列化，以便在进程间传递数据。 5. 断开共享内存连接：当不再需要访问共享内存区域时，需要调用 detach() 函数断开与共享内存的连接。 6. 删除共享内存区域：当所有进程都不再使用共享内存区域时，需要调用 QSharedMemory 的 static remove() 函数删除共享内存区域，释放资源。 需要注意的是，在使用共享内存进行进程间通信时，需要考虑数据同步和互斥等问题，以避免数据竞争和死锁等情况。同时，由于共享内存是操作系统资源，应该在使用完毕后及时释放，避免内存泄漏和资源浪费。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值