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进程间通讯的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

C语言泛型选择编程示例详解
这篇文章主要介绍了C语言泛型选择编程示例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
2023-09-09
总结UNIX/LINUX下C++程序计时的方法
本文总结了下UNIX/LINUX下C++程序计时的一些函数和方法，对日常使用C++程序的朋友很有帮助，有需要的小伙伴们可以参考学习，下面一起来看看吧。
2016-08-08
C++ 中继承与动态内存分配的详解
这篇文章主要介绍了C++ 中继承与动态内存分配的详解的相关资料,这里提供实例帮助大家学习理解这部分内容，需要的朋友可以参考下
2017-08-08
利用反射获得类的public static/const成员的值实例
下面小编就为大家带来一篇利用反射获得类的public static/const成员的值实例。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2016-12-12
Qt设计时钟效果
这篇文章主要为大家详细介绍了Qt设计时钟效果，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2020-05-05
c++代码各种注释示例详解
大家好，本篇文章主要讲的是c++代码各种注释示例详解，感兴趣的同学赶快来看一看吧，对你有帮助的话记得收藏一下，方便下次浏览
2021-12-12
C++小知识:复制粘贴代码千万要小心
今天小编就为大家分享一篇关于C++小知识:复制粘贴代码千万要小心，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
2019-01-01
C++ vector的常见用法超详细讲解
这篇文章主要介绍了C++ vector的常见用法,包括C++中vector容器的定义、初始化方法、访问元素、常用函数及其时间复杂度,通过代码介绍的非常详细,需要的朋友可以参考下
2025-04-04
详解C++11 线程休眠函数
这篇文章主要介绍了C++11 线程休眠函数的相关资料，帮助大家更好的理解和学习C++11,感兴趣的朋友可以了解下
2020-10-10
浅谈Windows系统下C语言编程中Glib库的使用
这篇文章主要介绍了Windows系统下C语言编程中Glib库的使用,Glib库在多线程编程中经常可以用到,需要的朋友可以参考下
2016-02-02

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

目录

设计思路

服务器实现

客户端实现

运行效果

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具