QT使用共享内存实现进程间通讯

更新时间：2024年12月13日 09:17:22 作者：hss2799

这篇文章主要为大家详细介绍了QT如何使用共享内存实现进程间通讯,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下

高性能：共享内存是进程间通信的最快方式之一，因为数据直接在内存中共享，不需要经过内核的系统调用或网络协议栈。
低延迟：由于数据直接在内存中传递，延迟非常低，适合需要高性能的场景（如实时数据处理、图像渲染等）。
简单数据共享：适合两个进程需要频繁访问相同数据的场景。

设计思路

共享内存区：用于存储数据。

互斥量：用于保护共享内存区，防止多个进程同时访问导致数据不一致。

信号量：用于通知对方有数据可用。

服务器实现

头文件

#ifndef SHAREDMEMORYSERVICE_H
#define SHAREDMEMORYSERVICE_H

#include <QObject>
#include <QSharedMemory>
#include <QBuffer>
#include <QDataStream>
#include <QDebug>
#include <QThread>
#include <QSystemSemaphore>

class SharedMemoryService : public QObject
{
    Q_OBJECT
public:
    explicit SharedMemoryService(QObject* parent = nullptr);
    ~SharedMemoryService();

    // 向共享内存中写入数据
    bool writeToSharedMemory(const QByteArray& data);

signals:
    // 当读取到共享内存中的数据时发出信号
    void signalRead(QBuffer& buffer);

private slots:
    // 检查共享内存中的数据
    void checkSharedMemory();

private:
    std::shared_ptr<QSharedMemory> m_sharedMemory; // 共享内存
    std::shared_ptr<QSystemSemaphore> m_semaphoreClient; // 信号量 - 客户端发送
    std::shared_ptr<QSystemSemaphore> m_semaphoreService; // 信号量- 服务器发送
    bool m_bCreate = false;                        // 是否创建成功
    bool m_bExit = false;                        // 是否退出
    QThread m_listenThread;                        // 监听线程
};

#endif // SHAREDMEMORYSERVICE_H

cpp

#include "SharedMemoryService.h"

SharedMemoryService::SharedMemoryService(QObject* parent)
    : QObject(parent),
    m_sharedMemory(std::make_shared<QSharedMemory>("MySharedMemoryKey_XXX")),
    m_semaphoreClient(std::make_shared<QSystemSemaphore>("MySemaphoreKey_XXX", 0)),
    m_semaphoreService(std::make_shared<QSystemSemaphore>("MySemaphoreKey_XXX2", 0))
{
    // 创建共享内存，大小为1024字节
    if (!m_sharedMemory->create(1024)) {
        qDebug() << "无法创建共享内存:" << m_sharedMemory->errorString();
        return;
    }
    m_bCreate = true;

    // 移动监听线程到单独的线程中
    QObject::connect(&m_listenThread, &QThread::started, this, &SharedMemoryService::checkSharedMemory, Qt::DirectConnection);
    m_listenThread.start();
}

SharedMemoryService::~SharedMemoryService()
{
    m_bExit = true;
    m_semaphoreClient->release(1);
    // 停止监听线程
    m_listenThread.quit();
    m_listenThread.wait();
}

void SharedMemoryService::checkSharedMemory()
{
    if (!m_bCreate || !m_sharedMemory->isAttached())
        return;

    while (true)
    {
        // 等待信号量
        if (m_semaphoreClient->acquire()) 
        {
            if (m_bExit)
            {
                break;
            }
            if (m_sharedMemory->lock()) 
            {
                // 读取共享内存中的数据
                QBuffer buffer;
                buffer.setData((char*)m_sharedMemory->data(), m_sharedMemory->size());
                buffer.open(QIODevice::ReadOnly);

                // 如果共享内存中有数据，则发出信号
                if (buffer.size() > 0) {
                    emit signalRead(buffer);

                    // 清空共享内存内容
                    memset(m_sharedMemory->data(), 0, m_sharedMemory->size());
                }

                // 解锁共享内存
                m_sharedMemory->unlock();
            }
        }
    }
}

bool SharedMemoryService::writeToSharedMemory(const QByteArray& data)
{
    if (!m_bCreate || !m_sharedMemory->isAttached())
    {
        qDebug() << "共享内存未创建或未附加";
        return false;
    }

    if (m_sharedMemory->lock()) {
        // 将数据写入共享内存
        memcpy(m_sharedMemory->data(), data.data(), qMin(data.size(), m_sharedMemory->size()));

        // 释放锁
        m_sharedMemory->unlock();

        // 增加信号量计数，通知监听线程有数据可用
        m_semaphoreService->release(1);

        return true;
    }

    qDebug() << "无法锁定共享内存";
    return false;
}

调用

/// 创建共享内存
void MainWindow::slotCrateBtn()
{
    if (m_service)
    {
        return;
    }
    ui->btnCreate->setEnabled(false);
    m_service = new SharedMemoryService();
    // 连接信号槽，监听共享内存中的数据
    QObject::connect(m_service, &SharedMemoryService::signalRead, this, &MainWindow::slotRecv, Qt::DirectConnection);
}

/// 发送内容
void MainWindow::slotSendBtn()
{
    if (m_service == nullptr)
    {
        return;
    }    
    // 向共享内存中写入数据
    QByteArray data = ui->textEditSend->toPlainText().toLocal8Bit();
    if (m_service->writeToSharedMemory(data))
    {
        qDebug() << "数据已成功写入共享内存";
    }
    else
    {
        qDebug() << "写入共享内存失败";
    }
}

/// 收到数据
void MainWindow::slotRecv(QBuffer& buffer)
{
    QString text = buffer.data();
    if (text.isEmpty())
    {
        return;
    }
    qDebug() << "接收到共享内存中的数据:" << text;
    ui->textEdit->append(text);
}

客户端实现

头文件

#ifndef SHAREDMEMORYCLIENT_H
#define SHAREDMEMORYCLIENT_H

#include <QObject>
#include <QSharedMemory>
#include <QBuffer>
#include <QDataStream>
#include <QDebug>
#include <QThread>
#include <QSystemSemaphore>

#include <cstdio>
#include <iostream>
#include <list>
#include <memory>
#include <string>

class SharedMemoryClient : public QObject
{
    Q_OBJECT
public:
    explicit SharedMemoryClient(QObject* parent = nullptr);

    ~SharedMemoryClient();

    // 向共享内存中写入数据
    bool writeToSharedMemory(const QByteArray& data);

signals:
    // 当读取到共享内存中的数据时发出信号
    void signalRead(QBuffer& buffer);

private slots:
    // 处理共享内存中的数据
    void processSharedMemory();

private:
    std::shared_ptr<QSharedMemory> m_sharedMemory; // 共享内存
    std::shared_ptr<QSystemSemaphore> m_semaphoreClient; // 信号量 - 客户端发送
    std::shared_ptr<QSystemSemaphore> m_semaphoreService; // 信号量- 服务器发送
    bool m_bCreate = false;                        // 是否创建成功
    bool m_bExit = false;                        // 是否退出
    QThread m_listenThread;                        // 监听线程
};

#endif // SHAREDMEMORYCLIENT_H

cpp

#include "SharedMemoryClient.h"

SharedMemoryClient::SharedMemoryClient(QObject* parent)
    : QObject(parent), m_sharedMemory(std::make_shared<QSharedMemory>("MySharedMemoryKey_XXX")),
    m_semaphoreClient(std::make_shared<QSystemSemaphore>("MySemaphoreKey_XXX", 0)),
    m_semaphoreService(std::make_shared<QSystemSemaphore>("MySemaphoreKey_XXX2", 0))
{
    if (!m_sharedMemory->attach()) {
        qDebug() << "无法附加到共享内存:" << m_sharedMemory->errorString();
        return;
    }
    m_bCreate = true;

    // 将处理方法移动到监听线程中
    moveToThread(&m_listenThread);
    connect(&m_listenThread, &QThread::started, this, &SharedMemoryClient::processSharedMemory, Qt::DirectConnection);

    // 启动监听线程
    m_listenThread.start();
}

SharedMemoryClient::~SharedMemoryClient()
{
    m_bExit = true;
    m_semaphoreService->release(1);
    // 停止监听线程
    m_listenThread.quit();
    m_listenThread.wait();
}

void SharedMemoryClient::processSharedMemory()
{
    while (true) 
    {
        if (m_semaphoreService->acquire())
        {
            if (m_bExit)
            {
                break;
            }
            if (!m_bCreate || !m_sharedMemory->isAttached())
                continue;

            // 锁定共享内存
            if (m_sharedMemory->lock())
            {
                // 检查共享内存是否有数据
                QBuffer buffer;
                buffer.setData((char*)m_sharedMemory->data(), m_sharedMemory->size());
                buffer.open(QIODevice::ReadOnly);

                // 如果共享内存中有数据，则发出信号
                if (buffer.size() > 0)
                {
                    emit signalRead(buffer);

                    // 清空共享内存内容
                    memset(m_sharedMemory->data(), 0, m_sharedMemory->size());
                }

                // 解锁共享内存
                m_sharedMemory->unlock();
            }
        }
    }
}

bool SharedMemoryClient::writeToSharedMemory(const QByteArray& data)
{
    if (!m_bCreate || !m_sharedMemory->isAttached())
    {
        qDebug() << "共享内存未创建或未附加";
        return false;
    }

    // 锁定共享内存
    if (m_sharedMemory->lock())
    {
        // 将数据写入共享内存
        memcpy(m_sharedMemory->data(), data.data(), qMin(data.size(), m_sharedMemory->size()));

        // 解锁共享内存
        m_sharedMemory->unlock();

        // 释放信号量，通知监听线程
        m_semaphoreClient->release(1);

        return true;
    }

    qDebug() << "无法锁定共享内存";
    return false;
}

调用

/// 连接共享内存
void MainWindow::slotCrateBtn()
{
    if (m_client)
    {
        return;
    }
    ui->btnCreate->setEnabled(false);
    m_client = new SharedMemoryClient();
    // 连接信号槽，监听共享内存中的数据
    QObject::connect(m_client, &SharedMemoryClient::signalRead, this, &MainWindow::slotRecv, Qt::DirectConnection);


}

/// 发送内容
void MainWindow::slotSendBtn()
{
    if (m_client == nullptr)
    {
        return;
    }
    // 向共享内存中写入数据
    QByteArray data = ui->textEditSend->toPlainText().toLocal8Bit();
    if (m_client->writeToSharedMemory(data))
    {
        qDebug() << "数据已成功写入共享内存";
    }
    else
    {
        qDebug() << "写入共享内存失败";
    }
}
/// 收到数据
void MainWindow::slotRecv(QBuffer& buffer)
{
    QString text = buffer.data();
    if (text.isEmpty())
    {
        return;
    }
    qDebug() << "接收到共享内存中的数据:" << text;
    ui->textEdit->append(text);
}

运行效果

以上就是QT使用共享内存实现进程间通讯的详细内容，更多关于QT进程间通讯的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

使用udp发送>=128K的消息会报ENOBUFS的错误的解决方法
在项目中选择了unix域的数据报套接口。在使用过程中碰到了如下，问题：发送<128K的消息时，客户、进程可以正常收发消息；发送>=128K的消息时，发送端(sendto)返回ENOBUFS的错误。下面小编来详细说下
2019-05-05
C++设计模式之访问者模式
这篇文章主要介绍了C++设计模式之访问者模式,本文讲解了什么是访问者模式、访问者模式的UML类图、访问者模式的实现代码等内容,需要的朋友可以参考下
2014-10-10
OpenCV实战之基于Hu矩实现轮廓匹配
这篇文章主要介绍了利用C++ OpenCV实现基于Hu矩的轮廓匹配，文中的示例代码讲解详细，对我们学习OpenCV有一定的帮助，感兴趣的可以学习一下
2022-01-01
C语言泛型编程实例教程
这篇文章主要介绍了C语言泛型编程,针对泛型的用法做了深入浅出的实例介绍,是C程序设计中非常实用的技巧,需要的朋友可以参考下
2014-09-09
详解C/C++实现各种字符转换方法合集
这篇文章主要为大家详细介绍了C/C++中实现各种字符转换的方法，文中的示例代码讲解详细，对我们学习C++具有一定借鉴价值，需要的可以参考一下
2022-09-09
基于Qt实现日志打印系统
这篇文章主要为大家详细介绍了如何利用Qt开发一个日志打印系统,可以实现打印日志按日期、大小保存,过期删除,窗口实时显示日志,网络传输日志远程调试,需要的可以参考下
2023-12-12
Qt实现简单UDP通信
这篇文章主要为大家详细介绍了Qt实现简单UDP通信，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2022-08-08
Qt学习之容器类的使用教程详解
Qt提供了多个基于模板的容器类，这些类可以用于存储指定类型的数据项。本文主要介绍了Qt常用容器类的使用，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2022-12-12
指针操作数组的两种方法(总结)
下面小编就为大家带来一篇指针操作数组的两种方法(总结)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2017-05-05
新旧MFC版本实现CEdit透明的2种方法的实例代码
新旧MFC版本实现CEdit透明的2种方法的实例代码，需要的朋友可以参考一下
2013-03-03

QT使用共享内存实现进程间通讯

目录

设计思路

服务器实现

客户端实现

运行效果

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具