QT使用共享內存實現(xiàn)進程間通訊

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

這篇文章主要為大家詳細介紹了QT如何使用共享內存實現(xiàn)進程間通訊,文中的示例代碼講解詳細,感興趣的小伙伴可以跟隨小編一起學習一下

高性能：共享內存是進程間通信的最快方式之一，因為數(shù)據直接在內存中共享，不需要經過內核的系統(tǒng)調用或網絡協(xié)議棧。
低延遲：由于數(shù)據直接在內存中傳遞，延遲非常低，適合需要高性能的場景（如實時數(shù)據處理、圖像渲染等）。
簡單數(shù)據共享：適合兩個進程需要頻繁訪問相同數(shù)據的場景。

設計思路

共享內存區(qū)：用于存儲數(shù)據。

互斥量：用于保護共享內存區(qū)，防止多個進程同時訪問導致數(shù)據不一致。

信號量：用于通知對方有數(shù)據可用。

服務器實現(xiàn)

頭文件

#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();

    // 向共享內存中寫入數(shù)據
    bool writeToSharedMemory(const QByteArray& data);

signals:
    // 當讀取到共享內存中的數(shù)據時發(fā)出信號
    void signalRead(QBuffer& buffer);

private slots:
    // 檢查共享內存中的數(shù)據
    void checkSharedMemory();

private:
    std::shared_ptr<QSharedMemory> m_sharedMemory; // 共享內存
    std::shared_ptr<QSystemSemaphore> m_semaphoreClient; // 信號量 - 客戶端發(fā)送
    std::shared_ptr<QSystemSemaphore> m_semaphoreService; // 信號量- 服務器發(fā)送
    bool m_bCreate = false;                        // 是否創(chuàng)建成功
    bool m_bExit = false;                        // 是否退出
    QThread m_listenThread;                        // 監(jiān)聽線程
};

#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))
{
    // 創(chuàng)建共享內存，大小為1024字節(jié)
    if (!m_sharedMemory->create(1024)) {
        qDebug() << "無法創(chuàng)建共享內存:" << m_sharedMemory->errorString();
        return;
    }
    m_bCreate = true;

    // 移動監(jiān)聽線程到單獨的線程中
    QObject::connect(&m_listenThread, &QThread::started, this, &SharedMemoryService::checkSharedMemory, Qt::DirectConnection);
    m_listenThread.start();
}

SharedMemoryService::~SharedMemoryService()
{
    m_bExit = true;
    m_semaphoreClient->release(1);
    // 停止監(jiān)聽線程
    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()) 
            {
                // 讀取共享內存中的數(shù)據
                QBuffer buffer;
                buffer.setData((char*)m_sharedMemory->data(), m_sharedMemory->size());
                buffer.open(QIODevice::ReadOnly);

                // 如果共享內存中有數(shù)據，則發(fā)出信號
                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() << "共享內存未創(chuàng)建或未附加";
        return false;
    }

    if (m_sharedMemory->lock()) {
        // 將數(shù)據寫入共享內存
        memcpy(m_sharedMemory->data(), data.data(), qMin(data.size(), m_sharedMemory->size()));

        // 釋放鎖
        m_sharedMemory->unlock();

        // 增加信號量計數(shù)，通知監(jiān)聽線程有數(shù)據可用
        m_semaphoreService->release(1);

        return true;
    }

    qDebug() << "無法鎖定共享內存";
    return false;
}

調用

/// 創(chuàng)建共享內存
void MainWindow::slotCrateBtn()
{
    if (m_service)
    {
        return;
    }
    ui->btnCreate->setEnabled(false);
    m_service = new SharedMemoryService();
    // 連接信號槽，監(jiān)聽共享內存中的數(shù)據
    QObject::connect(m_service, &SharedMemoryService::signalRead, this, &MainWindow::slotRecv, Qt::DirectConnection);
}

/// 發(fā)送內容
void MainWindow::slotSendBtn()
{
    if (m_service == nullptr)
    {
        return;
    }    
    // 向共享內存中寫入數(shù)據
    QByteArray data = ui->textEditSend->toPlainText().toLocal8Bit();
    if (m_service->writeToSharedMemory(data))
    {
        qDebug() << "數(shù)據已成功寫入共享內存";
    }
    else
    {
        qDebug() << "寫入共享內存失敗";
    }
}

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

客戶端實現(xiàn)

頭文件

#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();

    // 向共享內存中寫入數(shù)據
    bool writeToSharedMemory(const QByteArray& data);

signals:
    // 當讀取到共享內存中的數(shù)據時發(fā)出信號
    void signalRead(QBuffer& buffer);

private slots:
    // 處理共享內存中的數(shù)據
    void processSharedMemory();

private:
    std::shared_ptr<QSharedMemory> m_sharedMemory; // 共享內存
    std::shared_ptr<QSystemSemaphore> m_semaphoreClient; // 信號量 - 客戶端發(fā)送
    std::shared_ptr<QSystemSemaphore> m_semaphoreService; // 信號量- 服務器發(fā)送
    bool m_bCreate = false;                        // 是否創(chuàng)建成功
    bool m_bExit = false;                        // 是否退出
    QThread m_listenThread;                        // 監(jiān)聽線程
};

#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;

    // 將處理方法移動到監(jiān)聽線程中
    moveToThread(&m_listenThread);
    connect(&m_listenThread, &QThread::started, this, &SharedMemoryClient::processSharedMemory, Qt::DirectConnection);

    // 啟動監(jiān)聽線程
    m_listenThread.start();
}

SharedMemoryClient::~SharedMemoryClient()
{
    m_bExit = true;
    m_semaphoreService->release(1);
    // 停止監(jiān)聽線程
    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())
            {
                // 檢查共享內存是否有數(shù)據
                QBuffer buffer;
                buffer.setData((char*)m_sharedMemory->data(), m_sharedMemory->size());
                buffer.open(QIODevice::ReadOnly);

                // 如果共享內存中有數(shù)據，則發(fā)出信號
                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() << "共享內存未創(chuàng)建或未附加";
        return false;
    }

    // 鎖定共享內存
    if (m_sharedMemory->lock())
    {
        // 將數(shù)據寫入共享內存
        memcpy(m_sharedMemory->data(), data.data(), qMin(data.size(), m_sharedMemory->size()));

        // 解鎖共享內存
        m_sharedMemory->unlock();

        // 釋放信號量，通知監(jiān)聽線程
        m_semaphoreClient->release(1);

        return true;
    }

    qDebug() << "無法鎖定共享內存";
    return false;
}

調用

/// 連接共享內存
void MainWindow::slotCrateBtn()
{
    if (m_client)
    {
        return;
    }
    ui->btnCreate->setEnabled(false);
    m_client = new SharedMemoryClient();
    // 連接信號槽，監(jiān)聽共享內存中的數(shù)據
    QObject::connect(m_client, &SharedMemoryClient::signalRead, this, &MainWindow::slotRecv, Qt::DirectConnection);


}

/// 發(fā)送內容
void MainWindow::slotSendBtn()
{
    if (m_client == nullptr)
    {
        return;
    }
    // 向共享內存中寫入數(shù)據
    QByteArray data = ui->textEditSend->toPlainText().toLocal8Bit();
    if (m_client->writeToSharedMemory(data))
    {
        qDebug() << "數(shù)據已成功寫入共享內存";
    }
    else
    {
        qDebug() << "寫入共享內存失敗";
    }
}
/// 收到數(shù)據
void MainWindow::slotRecv(QBuffer& buffer)
{
    QString text = buffer.data();
    if (text.isEmpty())
    {
        return;
    }
    qDebug() << "接收到共享內存中的數(shù)據:" << text;
    ui->textEdit->append(text);
}