进程间通信-共享内存

把之前代码整理下，封装了一个用于共享内存的类。

头文件：CShareMem.h

/* @CShareMem类用于内存映射文件，在进程间传输帧数据 */
enum eDATATYPE { NONE_TYPE, FRAME_TYPE, STATUS_TYPE, INFO_TYPE, CMD_TYPE };
class CShareMem
{
public:
    enum EM_EVENS { EV_NONE, EV_READ_THIS, EV_WRITE_THIS, EV_READ_OTHER, EV_WRITE_OTHER, EV_TIMEOUT };
public: 
    struct SM_MEMFLAG
    {
        enum eMemFlag{ ACT_NONE, ACT_READ, ACT_WRITE } eLastAction;
        DWORD dwProcessId; 
        eDATATYPE eDataType;
        UDPFrameData m_DataHead;
        char m_DataBuff[BUFFER_SIZE];        // Text from client to server
    }; 
    class SM_MEMPTR
    {
    public: 
        ~SM_MEMPTR();
        SM_MEMFLAG* m_pMemFlag;
    private:
        friend class CShareMem;
        SM_MEMPTR(CShareMem&, SM_MEMFLAG*, SM_MEMFLAG::eMemFlag);
        CShareMem& m_ShareMemory; 
    };
    //
    CShareMem(CONST TCHAR* lpName = RZT_FRAME_RECV);
    ~CShareMem();
    /* @ 使用这个函数获得内存映射的指针，可用于直接存放或读取数据
       @ { std::auto_ptr<SM_MEMPTR> ptr = GetMemptr(SM_MEMFLAG::ACT_READ); use ptr .. }
    */
    std::auto_ptr<SM_MEMPTR> GetMemptr(SM_MEMFLAG::eMemFlag eFlag)
    {
        return auto_ptr<SM_MEMPTR>(new SM_MEMPTR(*this, m_pMemFlag,eFlag));
    }  
    EM_EVENS WaitEvent(DWORD dwTimeOut);
    void WaitEvent(EM_EVENS eEvent);
    bool Read(UDPFrameData* pDataHead, char* pData, eDATATYPE* type = nullptr);
    bool Write(UDPFrameData* pDataHead,const char* pData, eDATATYPE type = FRAME_TYPE);
private:
    DWORD m_dwProcessId;
    HANDLE m_hMemory;
    HANDLE m_hMutex;
    HANDLE m_hEvent;
    SM_MEMFLAG* m_pMemFlag;
    char * m_DataBuff;
    UDPFrameData * m_DataHead;
};

实现文件：CShareMem.cpp

CShareMem::CShareMem(CONST TCHAR* lpName):m_hMemory(NULL), m_hMutex(NULL), m_hEvent(NULL)
{ 
    m_dwProcessId = GetCurrentProcessId(); 
    if (!lpName)
    {
        lpName = _T("SHARE.MEMORY");
    }
    m_hMemory = ::CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, BUFFER_SIZE, lpName);
    if (::GetLastError() == ERROR_ALREADY_EXISTS)
    {
        m_hMemory = ::OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, lpName);
    }
    if (m_hMemory == NULL)
    {
        ostringstream os;
        os << "CreateFileMapping: %s Failed!" << lpName << endl;
        LOGFMTE(os.rdbuf()->str().c_str());
    }
    m_pMemFlag = (SM_MEMFLAG*)::MapViewOfFile(m_hMemory, FILE_MAP_ALL_ACCESS, 0, 0, sizeof(SM_MEMFLAG));
    m_DataBuff = m_pMemFlag->m_DataBuff;
    m_DataHead = &m_pMemFlag->m_DataHead;
    {
        TCHAR tcTempName[96] = _T("");
        _stprintf_s(tcTempName, _T("%s.Mutex"), lpName);
        m_hMutex = ::CreateMutex(NULL, FALSE, tcTempName);
        if (m_hMutex == NULL)
        {
            LOGFMTE(_T("CreateMutex %s Failed"), tcTempName);
        }
        _stprintf_s(tcTempName, _T("%s.Event"), lpName);
        m_hEvent = ::CreateEvent(NULL, TRUE, FALSE, tcTempName);
        if (m_hEvent == NULL)
        {
            LOGFMTE(_T("CreateEvent %s Failed"), tcTempName);
        }
    }
}
CShareMem::~CShareMem(void)
{
    ::UnmapViewOfFile(m_pMemFlag);
    ::CloseHandle(m_hMemory);
    ::CloseHandle(m_hMutex);
    ::CloseHandle(m_hEvent);
}
#define SM_LOCK ::WaitForSingleObject(m_hMutex, INFINITE)
#define SM_UNLOCK ::ReleaseMutex(m_hMutex)
#define SM_SIGNAR ::SetEvent(m_hEvent)
#define SM_RESETEVEN ::ResetEvent(m_hEvent)
CShareMem::SM_MEMPTR::SM_MEMPTR(CShareMem& ShareMemory, SM_MEMFLAG* pMemFlag, SM_MEMFLAG::eMemFlag eFlag)
    :m_ShareMemory(ShareMemory)
    ,m_pMemFlag(pMemFlag)
{ 
    ::WaitForSingleObject(m_ShareMemory.m_hMutex, INFINITE);  
    m_pMemFlag->dwProcessId = m_ShareMemory.m_dwProcessId;
    m_pMemFlag->eLastAction = eFlag;
}

CShareMem::SM_MEMPTR::~SM_MEMPTR()
{ 
    ::ReleaseMutex(m_ShareMemory.m_hMutex);
    ::SetEvent(m_ShareMemory.m_hEvent);
}
CShareMem::EM_EVENS CShareMem::WaitEvent(DWORD dwTimeOut)
{
    DWORD dwState = WaitForSingleObject(m_hEvent, dwTimeOut);
    EM_EVENS rtEvent = EV_NONE;
    SM_LOCK;
    switch (dwState)
    {
    case WAIT_OBJECT_0:
        switch (m_pMemFlag->eLastAction)
        {
        case SM_MEMFLAG::ACT_READ:
            rtEvent = m_pMemFlag->dwProcessId == m_dwProcessId ? EV_READ_THIS : EV_READ_OTHER;
            break;
        case SM_MEMFLAG::ACT_WRITE:
            rtEvent = m_pMemFlag->dwProcessId == m_dwProcessId ? EV_WRITE_THIS : EV_WRITE_OTHER; 
            break;
        } 
        break;
    case WAIT_TIMEOUT:
        rtEvent = EV_TIMEOUT;
        break;
    default:
        break;
    }
    SM_UNLOCK;
    SM_RESETEVEN;
    return rtEvent;
}

void CShareMem::WaitEvent(EM_EVENS eEvent)
{ 
    while (WaitEvent(INFINITE) != eEvent);
}
bool CShareMem::Write(UDPFrameData* pDataHead, const char* pData, eDATATYPE type)
{
    for (;;)
    {
        if (m_pMemFlag == NULL)
        {
            return false;
        }
        if (m_pMemFlag->eLastAction == SM_MEMFLAG::ACT_WRITE)
        {
            Sleep(1);
        }
        else
        {
            break;
        }
    }

    SM_LOCK; 
    memcpy_s(m_DataHead, HEADER_SIZE, pDataHead, HEADER_SIZE);
    memcpy_s(m_DataBuff, pDataHead->m_nFrameSize, pData, pDataHead->m_nFrameSize); 
    m_pMemFlag->eDataType = type;
    m_pMemFlag->dwProcessId = m_dwProcessId;
    m_pMemFlag->eLastAction = SM_MEMFLAG::ACT_WRITE;
    SM_SIGNAR;
    SM_UNLOCK;
    return true;
}
bool CShareMem::Read(UDPFrameData* pDataHead, char* pData, eDATATYPE* type)
{
    for(;;)
    {
        if (m_pMemFlag == NULL)
        {
            return false;
        }
        if (m_pMemFlag->eLastAction != SM_MEMFLAG::ACT_WRITE)//
        {
            Sleep(1);
        }
        else
        {
            break;
        }
    }
    SM_LOCK; 
    memcpy_s(pDataHead, HEADER_SIZE, m_DataHead, HEADER_SIZE);
    memcpy_s(pData, pDataHead->m_nFrameSize, m_DataBuff, pDataHead->m_nFrameSize);
    if (type)
    {
        *type = m_pMemFlag->eDataType;
    }
    m_pMemFlag->dwProcessId = m_dwProcessId;
    m_pMemFlag->eLastAction = SM_MEMFLAG::ACT_READ;
    SM_SIGNAR; 
    SM_UNLOCK;
    return true;
}