共享内存 ，同步机制

共享内存

Windows 下进程的地址空间在逻辑上是相互隔离的，但在物理上却是重叠的。所谓的重叠是指同一块内存区域可能被多个进程同时使用。

共享内存，各个进程可以共享同一块物理内存，进程可以直接读写内存，不需要数据拷贝。

由于多个进程共享一块内存，所以也需要同步机制

 

一实现步骤

步骤：

本进程创建

 1） 创建内存映射文件对象                 CreateFileMapping 

        Windows 即在物理内存申请一块指定大小的内存区域，，返回文件映射对象的句柄 hMap

2） 将内存对象映射在进程地址空间     MapViewOfFile 

 

其它进程访问

 其它进程访问这个内存对象时，   

1） OpenFileMapping 获取对象句柄，

2） 调用 MapViewOfFile映射在自己的进程空间

 

这样，同一块内存块被映射到了不同的进程空间，从而达到多个进程共享同一个内存块的目的。

 

简单示例：

#include <windows.h>
#include <iostream>
#include <string>
#include <cstring>
using namespace std;

int main()
{
    string strMapName("ShareMemory");                // 内存映射对象名称
    string strComData("This is common data!");        // 共享内存中的数据
    LPVOID pBuffer;                                    // 共享内存指针

    // 首先试图打开一个命名的内存映射文件对象  
    HANDLE hMap = ::OpenFileMapping(FILE_MAP_ALL_ACCESS, 0, strMapName.c_str());
    if (NULL == hMap)
    {    // 打开失败，创建之
        hMap = ::CreateFileMapping(INVALID_HANDLE_VALUE,
                                   NULL,
                                   PAGE_READWRITE,
                                   0,
                                   strComData.length()+1,
                                   strMapName.c_str());
        // 映射对象的一个视图，得到指向共享内存的指针，设置里面的数据
        pBuffer = ::MapViewOfFile(hMap, FILE_MAP_ALL_ACCESS, 0, 0, 0);
        strcpy((char*)pBuffer, strComData.c_str());
        cout << "写入共享内存数据：" << (char *)pBuffer << endl;
    }
    else
    {    // 打开成功，映射对象的一个视图，得到指向共享内存的指针，显示出里面的数据
        pBuffer = ::MapViewOfFile(hMap, FILE_MAP_ALL_ACCESS, 0, 0, 0);
        cout << "读取共享内存数据：" << (char *)pBuffer << endl;
    }

    getchar();            // 注意，进程关闭后，所有句柄自动关闭，所以要在这里暂停

    // 解除文件映射，关闭内存映射文件对象句柄
    ::UnmapViewOfFile(pBuffer);
    ::CloseHandle(hMap);
    system("pause");        
    return 0;
}

 

二 同步机制

 

m_hReadEvent = CreateEvent(NULL, true, true, L"Global\\ShareMemoryReadEvent");

m_hWriteEvent = CreateEvent(NULL, true, true, L"Global\\ShareMemoryWriteEvent");

 

   主进程负责写：

   这时，需要等待其它进程读操作完毕后，才能写

   而且，一旦主进程开始写，其它进程不能再去写

			if (pData)
			{
				WaitForSingleObject(m_memMng.m_hReadEvent, INFINITE);
				ResetEvent(m_memMng.m_hWriteEvent);

				memcpy((INT32*)pData, Info, sizeof(INT32)*len);

				memcpy(pData + 12, nim_nls::LssManange::GetVideoFrameMng()->capture_video_pic_.pdata_, nim_nls::LssManange::GetVideoFrameMng()->capture_video_pic_.size_);


				SetEvent(m_memMng.m_hWriteEvent);
			}

 

其它进程访问

   映射内存

mapping_ = OpenFileMapping(FILE_MAP_READ | FILE_MAP_WRITE, FALSE, L"Global\\ShareMemoryWriteEvent");

view_ = reinterpret_cast<char*>(::MapViewOfFile(shared_memory->mapping_, access, 0, 0, 0));

   

全局事件

			m_hReadEvent = OpenEvent(EVENT_MODIFY_STATE, TRUE, L"Global\\ShareMemoryReadEvent");
			m_hWriteEvent = OpenEvent(EVENT_MODIFY_STATE, TRUE, L"Global\\ShareMemoryWriteEvent");

读取这部分内存，

读取时，先确保主进程不在同时写

	WaitForSingleObject(m_memMng.m_hWriteEvent, INFINITE);
	ResetEvent(m_memMng.m_hReadEvent);
	char* pData = m_memMng.getData();
	if (pData)
	{

     。。。。

    }

    SetEvent(m_memMng.m_hReadEvent);

 

参考资料 

http://www.cnblogs.com/dongsheng/p/4460944.html

http://blog.chinaunix.net/uid-26833883-id-3230564.html