多進程C++（11）鏈表指針作爲全局變量

Question

我有經典的問題給出here，here和here，也here，

不過，我想一個子進程結束時插入元素的雙向鏈表。指向列表的第一個元素是全局的，我想訪問主進程中的所有列表元素，並且下一次我使用fork來分支main，我想要abe來訪問所有元素，並更新他們，並插入更多的元素，反過來主進程再次能夠訪問修改列表。

每個進程都會通過系統調用execvp退出（我需要他們能夠使用不同數量的參數調用內容）。

我或許在問一個太寬泛的問題，但我個人沒有得到比分支和在列表末尾插入元素更多的東西。因此，我實際上沒有一行代碼將我帶到了我想去的地方。我不知道如何在這種情況下使用shm（）。

請幫忙。

Answer 1

你可以試試這個..我只是寫的不是從頭開始。它是跨平臺的，所以這總是一個加號。分配器和池可以重用任何東西。例如，你可以做任何STL容器中的堆疊或任何你想要的分配..

SharedMemory.hpp：

#ifndef SHAREDMEMORY_HPP_INCLUDED 
#define SHAREDMEMORY_HPP_INCLUDED 

#if defined _WIN32 || defined _WIN64 
    #include <windows.h> 
#else 
    #include <sys/types.h> 
    #include <sys/mman.h> 
    #include <dlfcn.h> 
    #include <fcntl.h> 
    #include <unistd.h> 
#endif 

#include <string> 
#include <cstdint> 

class SharedMemory 
{ 
    private: 
     std::string name; 
     std::size_t size; 
     void* data; 
     void* hFileMap; 

    public: 
     SharedMemory(std::string name, std::size_t size) : name(name), size(size), data(nullptr), hFileMap(nullptr) {}; 
     ~SharedMemory(); 

     bool Open(); 
     bool Create(); 

     std::size_t GetSize() const {return this->size;} 
     void* GetPointer() const {return this->data;} 
}; 

#endif // SHAREDMEMORY_HPP_INCLUDED 

SharedMemory.cpp：

#include "SharedMemory.hpp" 

SharedMemory::~SharedMemory() 
{ 
    if (data) 
    { 
     #if defined _WIN32 || defined _WIN64 
     UnmapViewOfFile(data); 
     data = nullptr; 

     if (hFileMap) 
     { 
      if (CloseHandle(hFileMap)) 
      { 
       hFileMap = nullptr; 
      } 
     } 

     #else 

     if (data) 
     { 
      munmap(data, size); 
      data = nullptr; 
     } 

     if (hFileMap) 
     { 
      if (!close(hFileMap)) 
      { 
       hFileMap = nullptr; 
      } 
     } 
     #endif 
    } 
} 

bool SharedMemory::Open() 
{ 
    #if defined _WIN32 || defined _WIN64 
     if ((hFileMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, false, name.c_str())) == nullptr) 
     { 
      return false; 
     } 

     if ((data = MapViewOfFile(hFileMap, FILE_MAP_ALL_ACCESS, 0, 0, size)) == nullptr) 
     { 
      CloseHandle(hFileMap); 
      return false; 
     } 
    #else 

     if ((hFileMap = open(MapName.c_str(), O_RDWR | O_CREAT, 438)) == -1) 
     { 
      return false; 
     } 

     if ((data = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_FILE | MAP_SHARED, hFileMap, 0)) == MAP_FAILED) 
     { 
      close(hFileMap); 
      return false; 
     } 
    #endif 
    return true; 
} 

bool SharedMemory::Create() 
{ 
    #if defined _WIN32 || defined _WIN64 
     if ((hFileMap = CreateFileMapping(INVALID_HANDLE_VALUE, nullptr, PAGE_READWRITE, 0, size, name.c_str())) == nullptr) 
     { 
      return false; 
     } 

     if ((data = MapViewOfFile(hFileMap, FILE_MAP_ALL_ACCESS, 0, 0, size)) == nullptr) 
     { 
      CloseHandle(hFileMap); 
      return false; 
     } 

    #else 

     if ((hFileMap = open(MapName.c_str(), O_RDWR | O_CREAT, 438)) == -1) 
     { 
      return false; 
     } 

     if ((data = mmap(nullptr, Size, PROT_READ | PROT_WRITE, MAP_FILE | MAP_SHARED, hFileMap, 0)) == MAP_FAILED) 
     { 
      close(hFileMap); 
      return false; 
     } 
    #endif 
    return true; 
} 

Pools.hpp：

#ifndef POOLS_HPP_INCLUDED 
#define POOLS_HPP_INCLUDED 

#include <stdexcept> 
#include <cstdint> 
#include "SharedMemory.hpp" 

template<typename T> 
class SharedPool 
{ 
    private: 
     T* data; 
     SharedMemory* shm; 
     std::size_t size; 

    public: 
     SharedPool(SharedMemory* shm) : data(reinterpret_cast<T*>(shm->GetPointer())), shm(shm), size(shm->GetSize()) {}; 

     template<typename U = T> 
     void* allocate(std::size_t n, const void* hint = 0) {return &data[0];} 

     template<typename U = T> 
     void deallocate(U* ptr, std::size_t n) {} 

     template<typename U = T> 
     std::size_t max_size() const {return size;} 
}; 

#endif // POOLS_HPP_INCLUDED 

main.cpp中（來自過程中的一個添加值以共享存儲器）：

#include "SharedMemory.hpp" 
#include "Allocators.hpp" 
#include "Pools.hpp" 

#include <vector> 
#include <iostream> 

int main() 
{ 
    SharedMemory mem = SharedMemory("Local\\Test_Shared_Memory", 1024); 
    if (!mem.Open() && !mem.Create()) 
    { 
     throw std::runtime_error("Error Mapping Shared Memory!"); 
    } 

    auto pool = PoolAllocator<int, SharedPool<int>>(SharedPool<int>(&mem)); 
    std::vector<int, decltype(pool)> v(pool); 

    int* ptr = reinterpret_cast<int*>(mem.GetPointer()); 
    std::cout<<"Pushing 3 values to: "<<ptr<<"\n"; 

    v.push_back(100); 
    v.push_back(200); 
    v.push_back(700); 

    std::cin.get(); 
} 

main.cpp中（共享內存的過程中有兩個讀數值）：

#include "SharedMemory.hpp" 
#include "Allocators.hpp" 
#include "Pools.hpp" 

#include <vector> 
#include <iostream> 

int main() 
{ 
    SharedMemory mem = SharedMemory("Local\\Test_Shared_Memory", 1024); 
    if (!mem.Open() && !mem.Create()) 
    { 
     throw std::runtime_error("Error Mapping Shared Memory!"); 
    } 

    auto pool = PoolAllocator<int, SharedPool<int>>(SharedPool<int>(&mem)); 
    std::vector<int, decltype(pool)> v(pool); 

    int* ptr = reinterpret_cast<int*>(mem.GetPointer()); 
    std::cout<<"Reading 3 values from: "<<ptr<<"\n"; 

    v.reserve(3); 
    std::cout<<v[0]<<"\n"; 
    std::cout<<v[1]<<"\n"; 
    std::cout<<v[2]<<"\n"; 

    std::cin.get(); 
} 

Answer 2

這是一個棘手的問題。

一種方法是使用Shared Memory，並且當您構建鏈表時，給它一個自己的分配器，以使用共享內存。其他方法是基於共享內存實現您自己的鏈接列表。

您也可以嘗試使用boost - Boost interprocess，這可能是理想的解決方案。

具體來說 - interprocess with containers