2. 程式人生 > >Qt程序間共享記憶體例子

Qt程序間共享記憶體例子

阿新 • • 發佈：2019-01-11

一、現實需求：

專案中有一個FPGA需要實時高速大資料量採集投影資料，需要將驅動單獨編寫成一個程序，並將檔案地址及時共享給另外一個應用程式程序。

以前測試過將兩個程式放在一個程序裡，多執行緒執行。但是有應用程式處理過慢，迴圈佇列會溢位的問題。而且多次編譯程式，多次開啟驅動會導致硬體停止工作。

二、軟體需求：

1、寫程序，建立共享記憶體，不斷的往共享記憶體中寫檔案地址。

2、讀程序，開啟共享記憶體，不斷的從共享記憶體中讀檔案地址。

三、前提知識儲備：

1、QSystemSemaphore

2、QSharedMemory

四、程式碼測試例子：

1、首先是寫程序的程式。

WriteSharedMemory.h檔案

Cpp程式碼 
  1. #ifndef WRITESHAREDMEMORY_H  
  2. #define WRITESHAREDMEMORY_H  
  3. #include <QtGui/QMainWindow>  
  4. #include "ui_WriteSharedMemory.h"  
  5. #include <QSharedMemory>  
  6. #include <QSystemSemaphore>  
  7. class WriteSharedMemory : public QMainWindow  
  8. {  
  9.     Q_OBJECT  
  10. public:  
  11.     WriteSharedMemory(QWidget *parent = 0, Qt::WFlags flags = 0);  
  12.     ~WriteSharedMemory();  
  13.     ///可用空間  
  14.     static  QSystemSemaphore freeSystemSem;  
  15.     ///已用空間  
  16.     static  QSystemSemaphore usedSystemSem;  
  17. public slots:  
  18.     ///寫入共享記憶體  
  19.     void loadIntoSharedMem();  
  20.     void init();  
  21.     void write();  
  22.     QString read();  
  23.     ///迴圈寫  
  24.     void run();  
  25.     void
     detach();  
  26. private:  
  27.     Ui::WriteSharedMemoryClass ui;  
  28.     QSharedMemory sharedMem;  
  29.     int  num;  
  30. };  
  31. #endif // WRITESHAREDMEMORY_H  

 WriteSharedMemory.cpp檔案

Cpp程式碼 
  1. #include "WriteSharedMemory.h"  
  2. #include <QBuffer>  
  3. #include <QDebug>  
  4. WriteSharedMemory::WriteSharedMemory(QWidget *parent, Qt::WFlags flags)  
  5.     : QMainWindow(parent, flags),sharedMem("MySharedMemory")  
  6. {  
  7.     ui.setupUi(this);  
  8.     num = 0;  
  9.     init();  
  10.     //connect(ui.loadButton, SIGNAL(clicked()), SLOT(loadIntoSharedMem()));  
  11.     connect(ui.loadButton, SIGNAL(clicked()), SLOT(run()));  
  12.     connect(ui.initBtn, SIGNAL(clicked()), SLOT(init()));  
  13.     connect(ui.detachBtn, SIGNAL(clicked()), SLOT(detach()));  
  14. }  
  15. WriteSharedMemory::~WriteSharedMemory()  
  16. {  
  17. }  
  18. QSystemSemaphore WriteSharedMemory::freeSystemSem("freeFpga", 3, QSystemSemaphore::Create);  
  19. QSystemSemaphore WriteSharedMemory::usedSystemSem("usedFpga", 3, QSystemSemaphore::Create);  
  20. void WriteSharedMemory::init()  
  21. {  
  22.     // First, test whether a shared memory segment is already attached to the process.  
  23.     // If so, detach it  
  24.     if (sharedMem.isAttached())  
  25.     {  
  26.         if(!sharedMem.detach())  
  27.         {  
  28.             ui.textEdit->append("WriteSharedMemory : detach failed.");  
  29.             qDebug()<< "WriteSharedMemory : detach failed.";  
  30.             return;  
  31.         }  
  32.     }  
  33.     if ( !sharedMem.create( 1024 ) )   
  34.     {  
  35.         ui.textEdit->append(tr("Unable to create shared memory segment."));  
  36.         qDebug()<< "WriteSharedMemory::Unable to create shared memory segment.";  
  37.         return;  
  38.     }  
  39. }  
  40. void WriteSharedMemory::loadIntoSharedMem()  
  41. {  
  42.     write();  
  43. }  
  44. void WriteSharedMemory::run()  
  45. {  
  46.     while(1)  
  47.     {  
  48.         loadIntoSharedMem();  
  49.         _sleep(2);  
  50.     }  
  51. }  
  52. QString WriteSharedMemory::read()  
  53. {  
  54.     QBuffer buffer;  
  55.     QDataStream in(&buffer);  
  56.     QString text;  
  57.     sharedMem.lock();  
  58.     buffer.setData((char*)sharedMem.constData(), sharedMem.size());  
  59.     buffer.open(QBuffer::ReadOnly);  
  60.     in >> text;  
  61.     sharedMem.unlock();  
  62.     qDebug() << "WriteSharedMemory:: Read:" << text;  
  63.     return text;  
  64. }  
  65. void WriteSharedMemory::write( )  
  66. {  
  67.     QString text = read();  
  68.     QBuffer buffer;  
  69.     text = text + "C://project//projectFile" + QString::number(num) + ".txt;";  
  70.     buffer.open( QBuffer::ReadWrite );  
  71.     QDataStream out( &buffer );  
  72.     out << text;  
  73.     int size = buffer.size();  
  74.     if(sharedMem.size()<size)  
  75.     {  
  76.         qDebug() << "共享記憶體空間不夠！";  
  77.         return ;  
  78.     }  
  79.     num++;  
  80.     freeSystemSem.acquire();  
  81.     // Write into the shared memory  
  82.     sharedMem.lock();  
  83.     char *to = (char*)sharedMem.data();  
  84.     const char *from = buffer.data().data();  
  85.     memcpy( to, from, qMin( sharedMem.size(), size ) );  
  86.     sharedMem.unlock();  
  87.     usedSystemSem.release();  
  88.     ui.textEdit_2->append(text);  
  89.     qDebug() << "WriteSharedMemory:: Write:" << text;  
  90. }  
  91. void WriteSharedMemory::detach( )  
  92. {  
  93.     if (sharedMem.isAttached())  
  94.     {  
  95.         qDebug() << "attached";  
  96.         if(!sharedMem.detach())  
  97.             ui.textEdit->append("WriteSharedMemory:: detach failed.");  
  98.         else  
  99.             qDebug() << "WriteSharedMemory:: detached success.";  
  100.     }  
  101. }  

 ReadSharedMemory.h檔案

Cpp程式碼 
  1. #ifndef READSHAREDMEMORY_H  
  2. #define READSHAREDMEMORY_H  
  3. #include <QtGui/QMainWindow>  
  4. #include "ui_ReadSharedMemory.h"  
  5. #include <QSharedMemory>  
  6. #include <QSystemSemaphore>  
  7. class ReadSharedMemory : public QMainWindow  
  8. {  
  9.     Q_OBJECT  
  10. public:  
  11.     ReadSharedMemory(QWidget *parent = 0, Qt::WFlags flags = 0);  
  12.     ~ReadSharedMemory();  
  13.     ///可用空間  
  14.     static  QSystemSemaphore freeSystemSem;  
  15.     ///已用空間  
  16.     static  QSystemSemaphore usedSystemSem;  
  17. public slots:  
  18.     ///讀取共享記憶體  
  19.     void loadFromSharedMem();  
  20.     void read();  
  21.     ///迴圈讀  
  22.     void run();  
  23.     void detach();  
  24.     void attach();  
  25. private:  
  26.     Ui::ReadSharedMemoryClass ui;  
  27.     QSharedMemory sharedMem;  
  28. };  
  29. #endif // READSHAREDMEMORY_H  

 ReadSharedMemory.cpp檔案

Cpp程式碼 
  1. #include "ReadSharedMemory.h"  
  2. #include <QBuffer>  
  3. #include <QDataStream>  
  4. #include <QDebug>  
  5. ReadSharedMemory::ReadSharedMemory(QWidget *parent, Qt::WFlags flags)  
  6.     : QMainWindow(parent, flags),sharedMem("MySharedMemory")  
  7. {  
  8.     ui.setupUi(this);  
  9.     connect(ui.showButton, SIGNAL(clicked()), SLOT(run()));  
  10.     connect(ui.detachBtn, SIGNAL(clicked()), SLOT(detach()));  
  11.     connect(ui.attachBtn, SIGNAL(clicked()), SLOT(attach()));  
  12. }  
  13. ReadSharedMemory::~ReadSharedMemory()  
  14. {  
  15. }  
  16. QSystemSemaphore ReadSharedMemory::freeSystemSem("freeFpga", 3, QSystemSemaphore::Open);  
  17. QSystemSemaphore ReadSharedMemory::usedSystemSem("usedFpga", 3, QSystemSemaphore::Open);  
  18. void ReadSharedMemory::read()  
  19. {  
  20.     if(sharedMem.isAttached())  
  21.     {  
  22.         //qDebug() << "ReadSharedMemory:: haved attached.";  
  23.     }  
  24.     else   
  25.     {  
  26.         if(!sharedMem.attach())   
  27.         {  
  28.             //If an attempt of reading from the shared memory before data is written  
  29.             QSharedMemory::SharedMemoryError m = sharedMem.error();  
  30.             qDebug() << "ReadSharedMemory:: attach failed.";  
  31.             return;  
  32.         }  
  33.         else  
  34.         {  
  35.             qDebug() << "ReadSharedMemory:: attach success.";  
  36.         }  
  37.     }  
  38.     QBuffer buffer;  
  39.     QDataStream in(&buffer);  
  40.     QString text;  
  41.     usedSystemSem.acquire();  
  42.     sharedMem.lock();  
  43.     buffer.setData((char*)sharedMem.constData(), sharedMem.size());  
  44.     buffer.open(QBuffer::ReadOnly);  
  45.     in >> text;  
  46.     //清空快取  
  47.     char* to = (char*)sharedMem.data();  
  48.     memset(to,0,sharedMem.size());  
  49.     sharedMem.unlock();  
  50.     freeSystemSem.release();  
  51.     // As this is the last process attached to the shared memory segment  
  52.     // the shared memory segment is released, destroying its contents  
  53.     //sharedMem.detach();  

  54. 相關推薦

    Qt程序間共享記憶體例子

    一、現實需求： 專案中有一個FPGA需要實時高速大資料量採集投影資料，需要將驅動單獨編寫成一個程序，並將檔案地址及時共享給另外一個應用程式程序。 以前測試過將兩個程式放在一個程序裡，多執行緒執行。但是有應用程式處理過慢，迴圈佇列會溢位的問題。而且多次編譯程式，多次開啟

    檔案記憶體對映mmap解決大檔案快速讀寫問題和程序間共享記憶體

    mmap函式主要用途有三個： 1、將一個普通檔案對映到記憶體中，通常在需要對檔案進行頻繁讀寫時使用，這樣用記憶體讀寫取代I/O讀寫，以獲得較高的效能； 2、將特殊檔案進行匿名記憶體對映，可以為關聯程序提供共享記憶體空間； 3、為無關聯的程序提供共享記憶體空間，一般也是將一個普通檔案對映到

    互相獨立程序間共享記憶體互斥訪問的解決辦法

    前提：兩個程序互相獨立，訪問同一片共享記憶體存在問題：1、如何避免兩個程序同時訪問共享記憶體（一旦兩個程序同時訪問一個臨界區，後果是程式崩潰）2、如果使用互斥鎖，如何讓兩個程序拿到同一個互斥鎖解決辦法：針對問題1，可以使用訊號，訊號量，互斥鎖來進行同步，但是訊號和訊號量需要兩

    Boost.Interprocess使用手冊翻譯之四：在程序間共享記憶體 （Sharing memory between processes）

    共享記憶體 共享記憶體是最快速的程序間通訊機制。作業系統在幾個程序的地址空間上對映一段記憶體，然後這幾個程序可以在不需要呼叫作業系統函式的情況下在那段記憶體上進行讀/寫操作。但是，在程序讀寫共享記憶體時，我們需要一些同步機制。 考慮一下服務端程序使用網路機制在同一臺

    Qt程序間通訊——共享記憶體

           Qt提供了一種安全的共享記憶體的實現QSharedMemory，以便在多執行緒和多程序程式設計中安全的使用。比如說QQ的聊天的客戶端，這裡有個個性頭象，當點選QQ音樂播放器的時候，QQ

    程序間通訊 記憶體共享訊號量例項理解

    申請記憶體： int shmget(key_t key, size_t size, int shmflg); 其中key為鑰匙，兩程序通過同一個鑰匙找到核心中的共享記憶體，可通過 key_t ftok(const char *pathname, int proj_id)

    linux程序間通訊———記憶體共享

    共享記憶體（shared memory）：是linux下的多程序之間的通訊方法，這種方法通常用於一個程式的多程序間通訊，實際上多個程式間也可以通過共享記憶體來傳遞資訊。共享記憶體指在多處理器的計算機系統中，可以被不同中央處理器（CPU）訪問的大容量記憶體。由於多

    CreateFileMapping在N個程序間共享一個HWND型別記憶體

    Windows高深啊，做點東西要查來查去，把人腦創造性轉成機器服務 C/C++ code ? 1 2 3 4 5 6 7 8 9 10 11 12 13

    Linux下的多程序間共享資源的互斥訪問

    分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

    Python 程序間共享變數(多程序通訊安全)

    import multiprocessing import time def worker(d, key, value): d[key] = value if __name__ == '__main__': mgr = multiprocessing.Manager()

    作業系統（程序間共享儲存區的通訊）：建立一個共享儲存區，大小4個位元組（int大小）。建立一個子程序，然後子父程序獨自執行。父程序寫入一個數字到共享儲存區，子程序在共享儲存區把該數字讀出

    題目：建立一個共享儲存區，大小4個位元組（int大小）。建立一個子程序，然後子父程序獨自執行。父程序寫入一個數字到共享儲存區，子程序在共享儲存區把該數字讀出。 程式碼量很少，純屬應付作業 筆者在telnet上寫這些程式碼，由於知識技術及英語太菜，不知道怎樣在telnet上覆製出來這些程式碼，

    【Linux 程序】fork父子程序間共享資料分析

    之前我們通過fork()函式，得知了父子程序之間的存在著程式碼的拷貝，且父子程序都相互獨立執行，那麼父子程序是否共享同一段資料，即是否存在著資料共享。接下來我們就來分析分析父子程序是否存在著資料共享。 我們都知道，在linux下，記憶體儲存的位置是 全域性變數，棧區，堆區，以及檔案 。字元常量

    多程序程式設計——共享記憶體

    程序間通訊有四種方式：訊號量、管道、訊息佇列、共享記憶體 我們之前已著重介紹過訊號量、管道。 現著重介紹一下共享記憶體。 共享記憶體        共享記憶體是最高效的IPC機制，因為它不涉及程序之間任何的資料傳輸。這種高效率帶來的問題是，我們

    Linux程序通訊-共享記憶體

    共享記憶體是被多個程序共享的一部分實體記憶體。共享記憶體是程序間共享資料一種最快的方法，一個程序向共享記憶體區域寫入了資料，共享這個記憶體區域的所有程序就可以立刻看到其中的內容。 建立共享記憶體分為兩個步驟: 1、建立共享記憶體，使用shmget函式 2、對映共享記憶體，將這段建立的共

    Linux中的程序通訊-------共享記憶體

    一、什麼是共享記憶體 顧名思義，共享記憶體就是允許兩個不相關的程序訪問同一個邏輯記憶體。共享記憶體是在兩個正在執行的程序之間共享和傳遞資料的一種非常有效的方式。不同程序之間共享的記憶體通常安排為同一段實體記憶體。程序可以將同一段共享記憶體連線到它們自己的地址空間

    Windows程序間共享核心物件幾種方式

    核心物件的控制代碼是程序相關的，這樣更可靠，更安全；Windows提供下列N種機制來允許程序共享核心物件。 使用物件控制代碼繼承 只有程序間存在父子關係才能使用物件控制代碼繼承；系統會遍歷父程序的控制代碼表將所有有效的控制代碼完整的複製到子程序的控制代碼表中（這

    python爬蟲入門八：多程序/多執行緒 python佇列Queue Python多執行緒（2）——執行緒同步機制 python學習筆記——多程序中共享記憶體Value & Array python 之 多程序 Python多程序 Python 使用multiprocessing 特別耗記

    什麼是多執行緒/多程序 引用蟲師的解釋： 計算機程式只不過是磁碟中可執行的，二進位制（或其它型別）的資料。它們只有在被讀取到記憶體中，被作業系統呼叫的時候才開始它們的生命期。 程序（有時被稱為重量級程序）是程式的一次執行。每個程序都有自己的地址空間，記憶體，資料棧以及其它記錄其執行軌跡的輔助資料

    執行緒間共享資料例子--售票/退票

    例子程式: package edu.review; import java.util.Random; /** * 題目要求： * 兩個售票視窗，對某一趟列車票進行操作，一個為售票視窗，一個為退票視窗，每個視窗售/退票100張 **/ public c

    QT程序間通訊詳細介紹及QProcess機制分析

    1、QT通訊機制 為了更好的實現QT的資訊互動，在QT系統中建立了較為完善的通訊機制。QT的通訊可分為QT內部通訊和外部通訊兩大類。對於這兩類通訊機制及應用場合做如以下分析： （1）QT內部物件間通訊 在圖形使用者介面程式設計中，經常需要將一個視窗部件的變化通知給

    程序退出共享記憶體不一定釋放

    如下程式，在backtrace (array, 10)中，申請5次記憶體，程序退出並沒有立即釋放。Valgrind檢測結果如下： [[email protected] memory]# valgrind --tool=memcheck ./sample ==6452== Memcheck, a