利用QSystemSemaphore和QSharedMemory实现进程间通讯

https://blog.csdn.net/liji_digital/article/details/70547082

线程间的通讯可以由QSemaphore调控，以保证各个线程对同一资源的访问不冲突。

但是进程间的协调就不能利用QSemaphore，而要利用QSystemSemaphore。

此外，在同一进程内的各个线程之间可以用信号-槽机制通信，但是进程之间就不可以了。取而代之的是QSharedMemory。

下面的两个程序test_process和ProcessClient运行在不同的进程中。前者为主进程，后者为子进程。

主进程利用QProcess::start()启动子进程。QProcess::start(QString())的作用与在命令行输入命令类似。

start的输入参数可以是一个exe文件的名字。这个exe文件在另一个进程中运行。当主进程结束，exe所在的子进程也随之结束。

先看主进程的代码：

头文件

#ifndef MAINWINDOW_H
#define MAINWINDOW_H
 
#include <QMainWindow>
#include <QProcess>
#include <qfile.h>
#include <qsystemsemaphore.h>
#include <qsharedmemory.h>
 
namespace Ui {
class MainWindow;
}
 
class MainWindow : public QMainWindow
{
    Q_OBJECT
 
public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();
 
    QProcess        m_Proc;
    
    QSharedMemory    m_mem;
    
 
    static QSystemSemaphore            m_lockSrc;
    static QSystemSemaphore            m_lockDst;
 
    void            init();
    QString            read();
    void            write();
public slots:
    void            OnClickOK(void);
    void            OnRecvProc(void);
    void            OnClickSend(void);
private:
    Ui::MainWindow *ui;
};

在头文件中，我定义了主进程向子进程写入数据的函数write()，也定义了读出子进程数据的函数read()。在实际应用中，我只用到了write()。

cpp文件：

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QDebug>
#include <qbuffer.h>
 
 
MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
 
    QObject::connect(&m_Proc, SIGNAL(readyRead()), this, SLOT(OnRecvProc()));
    QObject::connect(ui->BtnOK, SIGNAL(clicked()), this, SLOT(OnClickOK()));
    QObject::connect(ui->BtnSend, SIGNAL(clicked()), this, SLOT(OnClickSend()));
 
    init();
}
 
MainWindow::~MainWindow()
{
    delete ui;
}
 
void MainWindow::init()
{
    m_mem.setKey(QString("sharedMem"));
    if (m_mem.isAttached())  
    {  
        m_mem.detach();
    }  
    m_mem.create(1024);
}
 
QSystemSemaphore MainWindow::m_lockSrc(QString("lockSrc"), 1, QSystemSemaphore::Create);
QSystemSemaphore MainWindow::m_lockDst(QString("lockDst"), 0, QSystemSemaphore::Create);
 
void MainWindow::OnClickOK(void)
{
    QString qstrCmd = ui->lineEdit->text();
    m_Proc.start(qstrCmd);
}
 
void MainWindow::OnClickSend(void)
{
    write();
}
 
void MainWindow::OnRecvProc(void)
{
    QByteArray qba = m_Proc.readAll();
    QString qstrFeedBack(qba);
 
    ui->textEdit->setText(qstrFeedBack);
}
 
QString MainWindow::read()  
{  
    QBuffer buffer;  
    QDataStream in(&buffer);  
    QString text;  
  
    m_mem.lock();  
    buffer.setData((char*)m_mem.constData(), m_mem.size());  
    buffer.open(QBuffer::ReadOnly);  
    in >> text;  
    m_mem.unlock();  
    qDebug() << "WriteSharedMemory:: Read:" << text;  
    return text;  
} 
 
void MainWindow::write( )  
{   
    QBuffer buffer;
    buffer.open( QBuffer::ReadWrite );  
    QDataStream out( &buffer );  
    QString text = ui->lineEdit->text();
    out << text;  
    int size = buffer.size();  
  
    if(m_mem.size()<size)  
    {  
        qDebug() << "共享内存空间不够！";  
        return ;  
    }  
    
  
    if(m_lockSrc.acquire())
    {
        // Write into the shared memory  
        m_mem.lock();  
        char *to = (char*)m_mem.data();  
        const char *from = buffer.data().data();  
        memcpy( to, from, qMin( m_mem.size(), size ) );  
        m_mem.unlock();  
        m_lockDst.release();
  
        qDebug() << "WriteSharedMemory:: Write:" << text;  
    }
}  

再看子进程。它包括两个类：Client和thrd。本来只要client一个类即可接收主线程发来的数据。但是实验发现那样会很卡顿。所以建立一个QThread的派生类--thrd。thrd负责接收主线程的数据。收到后，再利用信号槽机制传给Client，显示出来。通过开启一个线程的方式避免卡顿。
先看Client头文件：

#pragma once
 
#include <QWidget>
#include <qlineedit.h>
#include <QResizeEvent>
#include "thrd.h"
 
class Client : public QWidget
{
    Q_OBJECT
 
public:
    Client(QWidget *parent = 0);
    ~Client();
 
    thrd                        m_thrd;
    QLineEdit        *            m_pEdt;
public slots:
    void                    OnRecv(QByteArray);
protected:
    void                    resizeEvent(QResizeEvent *);
};

#include "client.h"
#include <QDebug>
#include <qbuffer.h>
#include <QMessageBox>
 
 
Client::Client(QWidget *parent)
    : QWidget(parent)
{
    QMessageBox msg;
    msg.setText("start");
    msg.exec();
 
    m_pEdt = new QLineEdit(this);
    QObject::connect(&m_thrd, SIGNAL(sigMsg(QByteArray)), this, SLOT(OnRecv(QByteArray)));
    
    m_thrd.start();
}
 
Client::~Client()
{
    m_thrd.terminate();
}
 
 
void Client::OnRecv(QByteArray qba)
{
    
    m_pEdt->setText(QString(qba));
}
 
void Client::resizeEvent(QResizeEvent *e)
{
    m_pEdt->setGeometry(width() / 10, height()/10, width() * 0.8, 20);
}

thrd.h

#pragma once
 
#include <qthread.h>
#include <qsystemsemaphore.h>
#include <qsharedmemory.h>
 
class thrd : public QThread
{
    Q_OBJECT
public:
    thrd(QObject * parent = 0);
    ~thrd();
 
    static QSystemSemaphore        m_lockSrc;
    static QSystemSemaphore        m_lockDst;
    QSharedMemory                m_mem;
    void                        read();
signals:
    void            sigMsg(QByteArray);
protected:
    void            run();
};

thrd.cpp

#include "thrd.h"
#include <qbuffer.h>
#include <qdatastream.h>
 
thrd::thrd(QObject * parent) : QThread(parent)
{
    m_mem.setKey(QString("sharedMem"));
}
 
thrd::~thrd()
{
}
 
QSystemSemaphore thrd::m_lockSrc(QString("lockSrc"), 1, QSystemSemaphore::Open);
QSystemSemaphore thrd::m_lockDst(QString("lockDst"), 0, QSystemSemaphore::Open);
 
void thrd::run()
{
    while(true)
    {
        read();
        msleep(1000);
    }
}
 
void thrd::read()  
{  
    if(m_mem.isAttached())  
    {  
        //qDebug() << "ReadSharedMemory:: haved attached.";  
    }  
    else   
    {  
        if(!m_mem.attach())   
        {  
            QSharedMemory::SharedMemoryError m = m_mem.error();  
            return;  
  
        }  
        else  
        {  
            //qDebug() << "ReadSharedMemory:: attach success.";  
        }  
    }  
  
    QBuffer buffer;  
    QDataStream in(&buffer);  
    QString text;  
  
    if(m_lockDst.acquire())
    {
        m_mem.lock();  
        buffer.setData((char*)m_mem.constData(), m_mem.size());  
        buffer.open(QBuffer::ReadOnly);  
        in >> text;  
        //清空缓存  
        char* to = (char*)m_mem.data();  
        memset(to,0,m_mem.size());  
        m_mem.unlock();  
  
        m_lockSrc.release();  
      
 
        QByteArray qba = text.toLatin1();
        emit sigMsg(qba);
    }
}  

子进程的共享内存QSharedMemory必须使用主进程的共享内存一样的名字，并且要使用同名的信号量。但使用时，只要open即可，不需要create。