Hello Qt（三十一）——QT进程间通信

一、TCP/IP

其实就是通过网络模块实现的IPC。不过Qt对其进行了封装，并提供了两个层次的API，包括应用程序级的QNetworkAccessManager, QFtp等和底层的QTcpSocket, QTcpServer, QSslSocket等。

二、QShared Memory（共享内存）

Qt提供的基于共享内存的IPC有QSharedMemory类和QSystemSemaphore类，QSharedMemory可以访问共享内存区域，以及多线程和进程的共享内存区域，而QSystemSemaphore类用于访问系统共享资源，以实现独立进程间的通信。

1、QSharedMemory

QSharedMemory读写内存时，可以使用lock()实现同步。如果同步完成，必须使用unlock()为共享内存区域解锁。

QSharedMemory可以使用attach()访问共享内存，通过指定参数来设置共享内存的访问模式。如果使用的是QSharedMemory::ReadOnly模式，则只能通过只读模式访问共享内存，如果使用QSharedMemory::ReadWrite模式则可以通过读写模式访问共享内存。

QSharedMemory拥有进程并提供可以返回共享内存区域指针的成员函数。在共享内存区域，成员函数constData()可以通过void 类型返回进程正在使用的内存区域指针。创建共享时，QSharedMemory可以以字节为单位分配共享内存区域，还可以通过第二个参数设置函数 attach()提供的模式。

QSharedMemory可以设置特定共享内存的固定key。函数setNativeKey()可以设置共享内存对象的key，setNativeKey()函数使用从属平台的共享内存的key进行相关设置。使用函数setKey()可以设置独立于平台的key。函数setKey()创建与平台本地key（Native Key）映射的key。

初始化QSharedMemory时，必须指定一个唯一的标识Key，进程的Key必须保持一致。可以使用setKey来设置。

2、QSystemSemaphore

QSystemSemaphore可以提供普通系统的信号量。信号量使用互斥体，而互斥体只可以使用1次锁定（Block）。因此，QSemaphore类不能对有效资源使用多线程，而QSystemSemaphore类可以在多进程或多线程中实现。

QSystemSemaphore与QSemaphore类不同，可以访问多进程。这表示QSystemSemaphore是一个重量级的类。因此，使用单一线程或进程时，建议使用QSemaphore。获得资源前，成员函数acquire()始终阻塞。函数release()用于释放资源，且该函数可以设置参数。该函数的参数>1时，释放资源。

3、QSharedMemory编程流程

共享内存中数据提供方：

A、定义QSharedMemory shareMemory,并设置标志名shareMemory.setKey();

B、将共享内存与主进程分离 shareMemory.detach()；

C、创建共享内存 shareMemory.create()；

D、将共享内存上锁shareMemory.lock()；

E、将进程中要共享的数据拷贝到共享内存中；

F、将共享内存解锁shareMemory.unlock()；

共享内存中数据使用方：

A、定义QSharedMemory shareMemory,并设置与共享内存提供方一致的标志名shareMemory.setKey（）。

B、将共享内存上锁shareMemory.lock()；

C、将共享内存与主进程绑定shareMemory.attach()，使主进程可以访问共享内存的数据；

D、从共享内存中取数据；

E、使用完后将共享内存解锁shareMemory.unlock()，并将共享内存与进程分离shareMemory.detach()；

4、QSharedMemory使用实例

共享内存数据提供方代码：

Widget.h文件：


#ifndef WIDGET_H
#define WIDGET_H
#include <QtGui/QWidget>
#include <QSharedMemory>
class Widget : public QWidget
{
    Q_OBJECT
public:
    Widget(QWidget *parent = 0);
    ~Widget();
private:
    QSharedMemory sharememory;
private slots:
    void WriteShareMemory();
};
#endif // WIDGET_H

Widget.cpp文件：


#include 'Widget.h'
#include <QBuffer>
#include <QDebug>
#include <QDataStream>
Widget::Widget(QWidget *parent): QWidget(parent)
{
    sharememory.setKey('share');
    this->WriteShareMemory();
}
Widget::~Widget()
{ 
}
void Widget::WriteShareMemory()
{
    if(sharememory.isAttached())
    {
        sharememory.detach();
    }
    QBuffer buffer;
    QDataStream out(&buffer);
    buffer.open(QBuffer::ReadWrite);
    buffer.write('hello QT!');
    int size = buffer.size();
    if(!sharememory.create(size))
    {
        qDebug() << sharememory.errorString();
        return ;
    }
    sharememory.lock();
    char *dest = reinterpret_cast<char *>(sharememory.data());
    const char *source = reinterpret_cast<const char *>(buffer.data().data());
    memcpy(dest, source, qMin(size, sharememory.size()));
    sharememory.unlock();
}

Main.cpp文件：


#include <QtGui/QApplication>
#include 'Widget.h'
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Widget w;
    w.show();
    return a.exec();
}

共享内存数据使用方代码：

Widget.h文件：


#ifndef WIDGET_H
#define WIDGET_H
#include <QtGui/QWidget>
#include <QSharedMemory>
class Widget : public QWidget
{
    Q_OBJECT
public:
    Widget(QWidget *parent = 0);
    ~Widget();
private:
    QSharedMemory sharememory;
private slots:
    void ReadShareMemory();
};
#endif // WIDGET_H

Widget.cpp文件：


#include 'Widget.h'
#include <QBuffer>
#include <QDebug>
#include <QDataStream>
Widget::Widget(QWidget *parent): QWidget(parent)
{
    sharememory.setKey('share');
    this->ReadShareMemory();
}
Widget::~Widget()
{
}
void Widget::ReadShareMemory()
{
    if(!sharememory.attach())
    {
        qDebug() << 'cann't attach sahrememory！';
    }
    QBuffer buffer;
    sharememory.lock();
    buffer.setData((char*)sharememory.constData(),sharememory.size());
    buffer.open(QBuffer::ReadWrite);
    buffer.readAll();
    sharememory.unlock();
    sharememory.detach();
    qDebug() << buffer.data().data();
}

Main.cpp文件：


#include <QtGui/QApplication>
#include 'Widget.h'
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Widget w;
    w.show();
    return a.exec();
}

三、D-Bus

D_BUS是一种低开销、低延迟的进程间通信机制。Qt提供了QtDBus模块，QtDBus模块使用D-Bus协议，把信号与槽机制（Signal and Slot）扩展到进程级别，使得开发者可以在一个进程中发出信号，可以再其他进程定义槽来响应其他进程发出的信号。

D-Bus是一种高级的进程间通信机制，由freedesktop.org项目提供，使用GPL许可证发行。D-Bus最主要的用途是在Linux桌面环境为进程提供通信，同时能将Linux桌面环境和Linux内核事件作为消息传递到进程。D-Bus的主要概率为总线，注册后的进程可通过总线接收或传递消息，进程也可注册后等待内核事件响应，例如等待网络状态的转变或者计算机发出关机指令。目前，D-Bus已被大多数Linux发行版所采用，开发者可使用D-Bus实现各种复杂的进程间通信任务。

D-Bus是一个消息总线系统，其功能已涵盖进程间通信的所有需求，并具备一些特殊的用途。D-Bus是三层架构的进程间通信系统，其中包括：

接口层：接口层由函数库libdbus提供，进程可通过libdbus库使用D-Bus的能力。

总线层：总线层实际上是由D-Bus总线守护进程提供的。在Linux系统启动时运行，负责进程间的消息路由和传递，其中包括Linux内核和Linux桌面环境的消息传递。

包装层：包装层一系列基于特定应用程序框架的Wrapper库。

在QT中的Dbus是使用的Dbus的包装层libdbus-qt.

要查看Dbus总线上的服务和对象可以借助d-feet 和qdbusviewer

要发送信号可以使用dbus-send,要查看Dbus上的消息流可以使用dbus-monitor

四、QCOP(Qt COmmunications Protocol )

QCOP 是 Qt 内部的一种通信协议，这种协议用于不同的客户之间在同一地址空间内部或者不同的进程之间的通信。目前，这种机制还只在 Qt 的嵌入式版本中提供。

为实现这种通信机制，Qt 中包括了由 QObject 类继承而来的 QCopChannel 类，该类提供了诸如 send()、isRegistered() 等静态函数，它们可以在脱离对象的情况下使用。为了在 channel 中接收通信数据，用户需要构造一个 QCopChannel 的子类并提供 receive() 函数的重载函数，或者利用 connect() 函数与接收到的信号相联系。值得一提的是，在 Qt 系统中，只提供了 QCOP 协议机制和用于接收消息的类，而如何发送消息则没有提供相应的类供用户使用。

在基于Qt的桌面系统Qtopia（QPE）中，则提供了相应的发送类：QCopEnvelope。用户可以通过该类利用channel向其他进程发送消息。该类将通过 QCopChannel 发送 QCop 消息的过程进行了封装，用户只需要调用该类中的相关函数就可以方便地实现进程之间的通信。

五、QProcess

跨平台类QProcess可以用于启动外部程序作为子进程，并与它们进行通信。QProcess提供了用于监测和控制该子进程状态的API。另外，QProcess为从QIODevice继承的子进程提供了输入/输出通道。

QProcess可以在应用程序内部与其它进程通信，或启动其它应用程序。与在终端机之类的命令输入窗口上使用名称和参数是一样的，可以使用QProcess提供的函数start()启动进程。可以注册QStringList处理进程后的参数。

1、带命令行参数启动

进程A-带参启动进程B

A、一般编写程序时，要启动外部程序，需要判断版本是debug还是release，否则，有可能会造成错误。

B、判断将要启动的进程是否存在，如果不存在，则启动；否则，不启动。

C、传参：json格式。


void onSendMessage()
{
    QString strExe('');
    if (m_pProcess == NULL)
        m_pProcess = new QProcess(this);
#if defined(QT_DEBUG)
    strExe = 'ReceiveMessaged.exe';
#   else
    strExe = 'ReceiveMessage.exe';
#  endif
    // 判断进程是否存在
    QProcess tasklist;
    tasklist.start('tasklist',
                   QStringList() << '/NH'
                   << '/FO' << 'CSV'
                   << '/FI' << QString('IMAGENAME eq %1').arg(strExe));
    tasklist.waitForFinished();
    QString strOutput = tasklist.readAllStandardOutput();
    if (!strOutput.startsWith(QString('\'%1').arg(strExe)))
    {
        QJsonObject json;
        json.insert('UserName', QStringLiteral('scorpio'));
        json.insert('Password', '123456');
        QJsonDocument document;
        document.setObject(json);
        QByteArray byteArray = document.toJson(QJsonDocument::Compact);
        QStringList arguments;
        arguments << byteArray;
        m_pProcess->startDetached(strExe, arguments);
    }
}

2、命令行读取

进程B-命令行读取

A、在main函数中初始化QApplication以后，获取命令行参数。

B、命令行参数中包含当前程序的名称、接收的参数等信息。


QStringList cmdLineArgs = QCoreApplication::arguments();
QMessageBox::information(NULL, QStringLiteral('ReceiveMessage'), 
                    cmdLineArgs.join(' '));

六、Session Management

在Linux/X11平台上，Qt提供了会话管理的支持。会话允许事件传播到进程，例如，当检测到关机时。进程和应用程序可以执行任何必要的操作，例如：保存打开的文档。

七、Windows消息

Windows消息机制可以实现进程间的通信。

1、发送消息

A、自定义消息类型与接收消息的窗口

包含所需库，定义发送消息的自定义类型、接收消息的窗体标题。自定义类型可以处理消息过多情况下，对消息的区分，如果不需要也可以去掉。


#ifdef Q_OS_WIN
#pragma comment(lib, 'user32.lib')
#include <qt_windows.h>
#endif
const ULONG_PTR CUSTOM_TYPE = 10000;
const QString c_strTitle = 'ReceiveMessage';

B、发送数据


    HWND hwnd = NULL;
    do
    {
        LPWSTR path = (LPWSTR)c_strTitle.utf16();  //path = L'SendMessage'
        hwnd = ::FindWindowW(NULL, path);
    } while (hwnd == (HWND)effectiveWinId()); // 忽略自己
    if (::IsWindow(hwnd))
    {
        QString filename = QStringLiteral('进程通信-Windows消息');
        QByteArray data = filename.toUtf8();
        COPYDATASTRUCT copydata;
        copydata.dwData = CUSTOM_TYPE;  // 用户定义数据
        copydata.lpData = data.data();  // 指向数据的指针
        copydata.cbData = data.size();  // 数据大小
        HWND sender = (HWND)effectiveWinId();
        ::SendMessage(hwnd, WM_COPYDATA, reinterpret_cast<WPARAM>(sender), 
                        reinterpret_cast<LPARAM>(©data));
    }

2、接收消息

A、设置标题

设置的窗口标题必须与发送消息指定的接收端窗口标题相同。

setWindowTitle('ReceiveMessage');

B、重写nativeEvent函数


bool Widget::nativeEvent(const QByteArray &eventType, void *message, long *result)
{
    MSG *param = static_cast<MSG *>(message);
    switch (param->message)
    {
    case WM_COPYDATA:
    {
        COPYDATASTRUCT *cds = reinterpret_cast<COPYDATASTRUCT*>(param->lParam);
        if (cds->dwData == CUSTOM_TYPE)
        {
            QString strMessage = QString::fromUtf8(reinterpret_cast<char*>(
                    cds->lpData), cds->cbData);
            QMessageBox::information(this, QStringLiteral('提示'), strMessage);
            *result = 1;
            return true;
        }
    }
    }
    return QWidget::nativeEvent(eventType, message, result);
}

3、程序实例

发送端：

Widget.h文件：


#ifndef WIDGET_H
#define WIDGET_H
#include <QWidget>
#include <QPushButton>
class Widget : public QWidget
{
    Q_OBJECT
private:
    QPushButton m_send;
private slots:
    void onSendMessage();
public:
    Widget(QWidget *parent = 0);
    ~Widget();
};
#endif // WIDGET_H

Widget.cpp文件：


#include 'Widget.h'
#ifdef Q_OS_WIN
#pragma comment(lib, 'user32.lib')
#include <qt_windows.h>
#endif
const ULONG_PTR CUSTOM_TYPE = 10000;
const QString c_strTitle = 'ReceiveMessage';
Widget::Widget(QWidget *parent):QWidget(parent),m_send(this)
{
    m_send.move(50, 50);
    m_send.resize(100,30);
    m_send.setText('SendMessage');
    connect(&m_send, SIGNAL(clicked(bool)), this, SLOT(onSendMessage()));
}
void Widget::onSendMessage()
{
    HWND hwnd = NULL;
    do
    {
        LPWSTR path = (LPWSTR)c_strTitle.utf16();  //path = L'SendMessage'
        hwnd = ::FindWindowW(NULL, path);
    } while (hwnd == (HWND)effectiveWinId()); // 忽略自己
    if (::IsWindow(hwnd))
    {
        QString filename = QStringLiteral('进程通信-Windows消息');
        QByteArray data = filename.toUtf8();
        COPYDATASTRUCT copydata;
        copydata.dwData = CUSTOM_TYPE;  // 用户定义数据
        copydata.lpData = data.data();  // 指向数据的指针
        copydata.cbData = data.size();  // 数据大小
        HWND sender = (HWND)effectiveWinId();
        ::SendMessage(hwnd, WM_COPYDATA, reinterpret_cast<WPARAM>(sender), 
                    reinterpret_cast<LPARAM>(©data));
    }
}
Widget::~Widget()
{
}

接收端：

Widget.h文件：


#ifndef WIDGET_H
#define WIDGET_H
#include <QWidget>
class Widget : public QWidget
{
    Q_OBJECT
private:
    bool nativeEvent(const QByteArray &eventType, void *message, long *result);
public:
    Widget(QWidget *parent = 0);
    ~Widget();
};
#endif // WIDGET_H

Widget.cpp文件：


#include 'Widget.h'
#include <QMessageBox>
#ifdef Q_OS_WIN
#pragma comment(lib, 'user32.lib')
#include <qt_windows.h>
#endif
const ULONG_PTR CUSTOM_TYPE = 10000;
Widget::Widget(QWidget *parent): QWidget(parent)
{
    setWindowTitle('ReceiveMessage');
}
Widget::~Widget()
{
}
bool Widget::nativeEvent(const QByteArray &eventType, void *message, long *result)
{
    MSG *param = static_cast<MSG *>(message);
    switch (param->message)
    {
    case WM_COPYDATA:
    {
        COPYDATASTRUCT *cds = reinterpret_cast<COPYDATASTRUCT*>(param->lParam);
        if (cds->dwData == CUSTOM_TYPE)
        {
            QString strMessage = QString::fromUtf8(reinterpret_cast<char*>(
                        cds->lpData), cds->cbData);
            QMessageBox::information(this, QStringLiteral('提示'), strMessage);
            *result = 1;
            return true;
        }
    }
    }
    return QWidget::nativeEvent(eventType, message, result);
}

本站仅提供存储服务，所有内容均由用户发布，如发现有害或侵权内容，请点击举报。