共享内存实用研究（一）

freeeyes

由于最近一段时间较忙，事情较多，一直没有时间发布新帖。因为以前做过一些游戏服务器的需求，所以希望在这里把自己的一些游戏服务器设计经验一点点共享出来，供大家参考，当然，对于我个人而言，我想借助这些文章，沉淀一下自己的知识，抽象一下以前的代码。当然，可能有的并不完善，欢迎大家提出自己的意见和想法。
由于有些代码是商业的，不能公开，所以我以我的理解重写了，或许有些问题的地方，还请各位指正。
以下代码我都会以附件的形式贴出来。这里只写一些主要的部分。
我觉得共享内存，在服务器应用中是很有用的一个东西，尤其在跨进程访问的时候，比如，我从数据库读取一些用户信息，预先放进共享内存，然后，另外的一个进程通过这个结构去访问这些数据。这样做的好处是，就算其中一个服务器宕机，只要另外的服务器还在运行，共享内存就会得以保存，当宕机的服务器重启之后，能还原到宕机那一时刻的数据。在网络游戏中应用尤其多，但是同样，共享内存是一个双刃剑，难处理的是跨进程的读写操作，容易造成一些领崩溃的问题。不过，这些困难，是可以通过设计减少它的发生概率的。
呵呵，废话少说了，先从最基本的开始吧。
由于windows和linux下的共享内存不太一样，所以写一个跨平台的共享内存模块是有一定意义的。于是，在这里，先写一个这样的东东吧。
windows的共享内存是指，
其实网上写的很多，不过还是自己写了一个，毕竟觉得自己写也不难，其实也没多少代码，关键在思路。

2. namespace ShareMemoryAPI
3. {
4.         //创建一个ShareMemory对象指针
5.         SMHandle CreateShareMemory(SMKey Key, int nSize);
7.         //打开一个已经存在的ShareMemory对象指针
8.         SMHandle OpenShareMemory(SMKey pKey, int nSize);
10.         //得到指定的ShareMemory对象指针映射
11.         char* MapShareMemory(SMHandle handle);
13.         //关闭指定的ShareMemory对象指针映射
14.         void UnMapShareMemory(char* pData);
16.         void CloseSharememory(SMHandle handle);
17. };

复制代码

首先封装一下简单的调用API，因为windows下用的句柄，而 linux下用的是一个序号。要想完全兼容有些麻烦，所以我设计了SMHandle对象和SMKey对象，用于兼容在windows和linux下的统一性。
其实看上面的API，就四个，不多，其实这么多也就够用了。在复杂的共享内存应用，大多也都是它们衍生的。

2. //如果是windows，定义对象
3. #ifdef _WIN32
4.         #define INIT_HANDLE 0xFFFFFFFFFFFFFFFF
5.         typedef HANDLE         SMHandle;
6.         typedef int                 SMKey;
7. #endif
9. //如果是linux，定义对象
10. #ifdef  _LINUX
11.         typedef int     SMHandle;
12.         typedef key_t SMKey;
13. #endif

复制代码

这里，我约定了所有的ShareMemory的标记都是int，为了统一，当在windows的时候，我会把这个标记转化为char*。

然后，我建立了一个类，负责记录用户创建的ShareMemory对象。

2. class CSMAccessObject
3. {
4. public:
5.         CSMAccessObject(void);
6.         ~CSMAccessObject(void);
8.         //创建对象
9.         bool Create(SMKey key, int nSize);
11.         //删除对象
12.         void Destory();
14.         //检测对象是否存在，如果存在则不再创建，直接打开
15.         bool Open(SMKey key, int nSize);
17.         //得到指定长度偏移的指针位置
18.         char* GetData(int nSize);
20.         //得到此对象的总长度
21.         int GetSize();
23. private:
24.         SMHandle m_SMHandle;
25.         SMKey    m_Key;
26.         int      m_nSize;
27.         char*    m_pData;
28. };

复制代码

这个对象的主要目的是，创建或者维护一个块指定长度的CSMAccessObject对象。 这里的方法都是用ShareMemoryAPI下的命令处理的。
这里要说明的是在windows下，SMHandle的类型是Handle类型，一个句柄指针。而在linux下，是int类型，一个位置。当然，在64位的系统下，这个int要注意它的实际长度。而key关键字就比较麻烦了，在wondiws下，key可以是一个char*，一个字符串，而在linux下，这个key是一个key_t类型（实际是一个int类型），而这个key必须通过匹配获得。这个匹配是指定一个linux的共享内存路径，比如ftok("/home/freeeyes/src/SMData/", 0);这将会返回一个key类型。如果返回的是-1表示获取唯一ID失败，这和windows返回句柄为NULL(0)是不同的。
windows的共享内存机制是，当有一个程序在使用它的时候，它的计数器就会+1，当有进程离开的时候，计数器-1，当计数器为0的时候，系统释放共享内存对象。而在linux下是当共享内存建立，就会一直存在，直到有一个进程给它释放关闭的命令，它才会释放。
有了这些API，在上面我手动封装了一个AccessObject的类，负责创建，打开，映射共享内存地址。

2. #include "ShareMemoryAPI.h"
4. class CSMAccessObject
5. {
6. public:
7.         CSMAccessObject(void);
8.         ~CSMAccessObject(void);
10.         //创建对象，创建的内存为实际内存+头描述
11.         bool Create(SMKey key, int nSize, int nHeadSize);
13.         //检测对象是否存在，如果存在则不再创建，直接打开
14.         bool Open(SMKey key, int nSize, int nHeadSize);
16.         //删除对象
17.         void Destory();
19.         //得到指定长度偏移的指针位置
20.         char* GetData(int nSize);
22.         //得到头描述的位置
23.         char* GetHeadData();
25.         //得到此对象的总长度
26.         int GetDataSize();
28.         //得到此对象的头总长度
29.         int GetHeadDataSize();
31. private:
32.         SMHandle m_SMHandle;
33.         SMKey    m_Key;
34.         int      m_nSize;
35.         int      m_nHeadSize;
36.         char*    m_pHeadData;
37.         char*    m_pData;
38. };

复制代码

这是一个指定的共享内存对象，这里做了一个m_pHeadData和m_pData两个指针对象，m_pHeadData用于记录此共享内存的内存分配信息（下面会说明这段内存存的是什么），而m_pData记载的是共享内存头的指针位置。比如，当我申请一个内存的时候，实际是m_nHeadSize + m_nSize。一个头信息块+要使用的内存大小。
有了这些，我就可以封装一个共享内存的模板了。因为大多数时候，我需要一些不同的共享内存对象，最简单的方法就是提供类似new和delete的支持功能，就像C++本身那样，可以随意的申请和"释放"（这里的释放不是真的释放，只是标记一下）。
本着这个原则，我创建了一个模板类。

2. #ifndef _SMPOOL_H
3. #define _SMPOOL_H
5. #include "SMAccessObject.h"
6. #include "Serial.h"
8. #include <map>
10. using namespace std;
12. template<typename T>
13. class CSMPool
14. {
15. public:
16.         CSMPool()
17.         {
18.                 m_pSMAccessObject = NULL;
19.         };
21.         ~CSMPool()
22.         {
23.                 if(m_pSMAccessObject != NULL)
24.                 {
25.                         delete m_pSMAccessObject;
26.                         m_pSMAccessObject = NULL;
27.                 }
28.         };
30.         bool Init(SMKey key, int nMaxCount)
31.         {
32.                 bool blRet = false;
34.                 //初始化序列化头
35.                 m_Serial.Init(nMaxCount*sizeof(_SMBlock));
37.                 m_pSMAccessObject = new CSMAccessObject();
38.                 if(NULL == m_pSMAccessObject)
39.                 {
40.                         return false;
41.                 }
43.                 //首先尝试打开，看看是否存在已有，如果不存在，则创建新的。
44.                 blRet = m_pSMAccessObject->Open(key, nMaxCount*sizeof(T), nMaxCount*sizeof(_SMBlock));
45.                 if(false == blRet)
46.                 {
47.                         printf("[Init]Create.\n");
48.                         //如果没有，则新建。
49.                         blRet = m_pSMAccessObject->Create(key, nMaxCount*sizeof(T), nMaxCount*sizeof(_SMBlock));
50.                         if(false == blRet)
51.                         {
52.                                 return false;
53.                         }
55.                         //开始划分共享内存空间
56.                         m_mapSMBlock.clear();
57.                         m_mapFreeSMBlock.clear();
58.                         m_mapUsedSMBlock.clear();
59.                         for(int i = 0; i < nMaxCount; i++)
60.                         {
61.                                 _SMBlock* pSMBlock = new _SMBlock();
62.                                 if(pSMBlock == NULL)
63.                                 {
64.                                         return false;
65.                                 }
67.                                 pSMBlock->m_nID = i;
68.                                 pSMBlock->m_pT  = reinterpret_cast<T*>(m_pSMAccessObject->GetData(i*sizeof(T)));
69.                                 if(NULL == pSMBlock->m_pT)
70.                                 {
71.                                         return false;
72.                                 }
73.                                 m_mapSMBlock.insert(typename mapSMBlock::value_type(i, pSMBlock));
74.                                 m_mapFreeSMBlock.insert(typename mapFreeSMBlock::value_type(i, pSMBlock));
75.                                 m_Serial.Serial(pSMBlock, sizeof(_SMBlock));
76.                         }
78.                         m_nMaxCount = nMaxCount;
79.                         //写入消息头
80.                         WriteSMHead();
81.                 }
82.                 else
83.                 {
84.                         printf("[Init]Open.\n");
85.                         //如果存在则读取
86.                         char* pHeadData = m_pSMAccessObject->GetHeadData();
87.                         if(NULL == pHeadData)
88.                         {
89.                                 return false;
90.                         }
91.                         //printf("[Init]Open pHeadData = 0x%08x.\n", pHeadData);
93.                         //读取共享内存中关于数据的判定
94.                         m_Serial.Serial(pHeadData, nMaxCount*sizeof(_SMBlock));
96.                         //还原回vector对象
97.                         m_mapSMBlock.clear();
98.                         m_mapFreeSMBlock.clear();
99.                         m_mapUsedSMBlock.clear();
100.                         for(int i = 0; i < nMaxCount; i++)
101.                         {
102.                                 _SMBlock* pSMBlock = new _SMBlock();
103.                                 if(pSMBlock == NULL)
104.                                 {
105.                                         return false;
106.                                 }
108.                                 m_Serial.GetData(pSMBlock, sizeof(_SMBlock));
109.                                 pSMBlock->m_pT  = reinterpret_cast<T*>(m_pSMAccessObject->GetData(i*sizeof(T)));
110.                                 m_mapSMBlock.insert(typename mapSMBlock::value_type(pSMBlock->m_nID, pSMBlock));
112.                                 //分类
113.                                 if(pSMBlock->m_blUse == true)
114.                                 {
115.                                         //放入正在使用的列表
116.                                         m_mapUsedSMBlock.insert(typename mapUsedSMBlock::value_type(pSMBlock->m_pT, pSMBlock));
117.                                 }
118.                                 else
119.                                 {
120.                                         //放入没有使用的列表
121.                                         m_mapFreeSMBlock.insert(typename mapFreeSMBlock::value_type(i, pSMBlock));
122.                                 }
123.                         }
125.                         m_nMaxCount = nMaxCount;
126.                 }
129.                 return true;
130.         };
132.         void Close()
133.         {
134.                 typename mapSMBlock::iterator b = m_mapSMBlock.begin();
135.                 typename mapSMBlock::iterator e = m_mapSMBlock.end();
136.                 for(b; b != e; b++)
137.                 {
138.                         _SMBlock* pSMBlock = (_SMBlock* )b->second;
139.                         if(pSMBlock != NULL)
140.                         {
141.                                 delete pSMBlock;
142.                         }
143.                 }
144.                 m_mapSMBlock.clear();
146.                 m_pSMAccessObject->Destory();
147.         }
149.         T* NewObject()
150.         {
151.                 //在m_mapSMBlock中查找一个空余的对象。
152.                 if(m_mapFreeSMBlock.size() > 0)
153.                 {
154.                         typename mapFreeSMBlock::iterator b = m_mapFreeSMBlock.begin();
155.                         _SMBlock* pSMBlock = (_SMBlock* )b->second;
156.                         if(NULL == pSMBlock)
157.                         {
158.                                 return NULL;
159.                         }
160.                         else
161.                         {
162.                                 m_mapFreeSMBlock.erase(b);
163.                                 pSMBlock->m_blUse = true;
164.                                 m_mapUsedSMBlock.insert(typename mapUsedSMBlock::value_type(pSMBlock->m_pT, pSMBlock));
166.                                 m_Serial.WriteData(pSMBlock->m_nID*sizeof(_SMBlock), pSMBlock, sizeof(_SMBlock));
167.                                 //写入消息头
168.                                 WriteSMHead();
170.                                 return pSMBlock->m_pT;
171.                         }
172.                 }
173.                 else
174.                 {
175.                         return NULL;
176.                 }
177.         };
179.         bool DeleteObject(T* pData)
180.         {
181.                 typename mapUsedSMBlock::iterator f = m_mapUsedSMBlock.find(pData);
182.                 if(f == m_mapUsedSMBlock.end())
183.                 {
184.                         return false;
185.                 }
186.                 else
187.                 {
188.                         _SMBlock* pSMBlock = (_SMBlock* )f->second;
189.                         m_mapUsedSMBlock.erase(f);
190.                         pSMBlock->m_blUse = false;
191.                         m_mapFreeSMBlock.insert(typename mapFreeSMBlock::value_type(pSMBlock->m_nID, pSMBlock));
193.                         m_Serial.WriteData(pSMBlock->m_nID*sizeof(_SMBlock), pSMBlock, sizeof(_SMBlock));
194.                         //写入消息头
195.                         WriteSMHead();
196.                         return true;
197.                 }
198.         };
200.         int GetFreeObjectCount()
201.         {
202.                 return (int)m_mapFreeSMBlock.size();
203.         }
205.         int GetUsedObjectCount()
206.         {
207.                 return (int)m_mapUsedSMBlock.size();
208.         };
210.         T* GetUsedObject(int nIndex)
211.         {
212.                 if(nIndex >= (int)m_mapUsedSMBlock.size())
213.                 {
214.                         return NULL;
215.                 }
217.                 typename mapUsedSMBlock::iterator b = m_mapUsedSMBlock.begin();
218.                 typename mapUsedSMBlock::iterator e = m_mapUsedSMBlock.end();
220.                 int nPos = 0;
221.                 for(b; b != e; b++)
222.                 {
223.                         if(nPos == nIndex)
224.                         {
225.                                 _SMBlock* pSMBlock = (_SMBlock* )b->second;
226.                                 if(NULL != pSMBlock)
227.                                 {
228.                                         return pSMBlock->m_pT;
229.                                 }
230.                                 else
231.                                 {
232.                                         return NULL;
233.                                 }
234.                         }
235.                         else
236.                         {
237.                                 if(nPos > nIndex)
238.                                 {
239.                                         return NULL;
240.                                 }
241.                                 nPos++;
242.                         }
243.                 }
245.         }
247. private:
248.         void WriteSMHead()
249.         {
250.                 char* pHeadData = m_pSMAccessObject->GetHeadData();
251.                 if(NULL == pHeadData)
252.                 {
253.                         return;
254.                 }
256.                 //将头信息写入共享内存头
257.                 memcpy(pHeadData, m_Serial.GetBase(), m_nMaxCount*sizeof(_SMBlock));
258.         };
260. private:
261.         //记录每个队列的数据容器
262.         struct _SMBlock
263.         {
264.                 T*   m_pT;
265.                 int  m_nID;
266.                 bool m_blUse;
268.                 _SMBlock()
269.                 {
270.                         m_pT    = NULL;
271.                         m_nID   = 0;
272.                         m_blUse = false;
273.                 }
274.         };
275.         typedef map<int, _SMBlock*> mapSMBlock;
276.         typedef map<T*, _SMBlock*>  mapUsedSMBlock;
277.         typedef map<int, _SMBlock*> mapFreeSMBlock;
279. private:
280.         CSMAccessObject* m_pSMAccessObject;
281.         mapSMBlock       m_mapSMBlock;
282.         mapUsedSMBlock   m_mapUsedSMBlock;
283.         mapFreeSMBlock   m_mapFreeSMBlock;
284.         CSerial          m_Serial;
285.         int              m_nMaxCount;
286. };
288. #endif

复制代码

代码有点多，实际多的那部分，是关于头标记的部分。
因为很多时候，程序会因为各种原因而崩溃。而再次重启的时候，可能有些共享内存对象已经被分配出去了。这时候如果我再new出来，可能就会覆盖原有的数据，所以我把所有的内存块都存成一个数据结构，放在共享内存的头里面，当下次程序启动，我会预读这个头，并还原内存使用列表，最大限度的保证数据获取与写入的正确。
使用的话么，呵呵，其实很简单。

2. struct _Data   //一个测试的对象
3. {
4.         int  m_nData;
5.         char m_szData[20];
7.         _Data()
8.         {
9.                 m_nData     = 0;
10.                 m_szData[0] = '\0';
11.         }
12. };
14. #ifdef _WIN32
15.         int _tmain(int argc, _TCHAR* argv[])
16. #else
17.   int main(int argc, char* argv[])
18. #endif
19. {
20.         CSMPool<_Data> UserPool;   
22.         SMKey key;
23.        
24. #ifdef _WIN32       
25.         key = 1111;
26. #else
27.     key = ftok("/home/freeeyes/SMData/", 0);
28. #endif
30.         printf("[Test]%d.\n", key);
31.         UserPool.Init(key, 100);
33.         _Data* pData1 = UserPool.NewObject();
34.         if(NULL == pData1)
35.         {
36.                 printf("[main]Get Data1 NULL.\n");
37.         }
38.         else
39.         {
40.                 pData1->m_nData = 1;
41.                 sprintf(pData1->m_szData, "shiqiang");
42.                 printf("[main]Free Count = %d.\n", UserPool.GetFreeObjectCount());
43.                 printf("[main]Get Data1 OK[%d] - [%s].\n", pData1->m_nData, pData1->m_szData);
44.         }
45. }

复制代码

呵呵，一个很简单使用共享内存的例子。
其实，要想真正把共享内存做的更完美一些，需要一些手段，下一讲我将着重介绍如何使用共享内存的一些简单策略，比如如何防止不同的进程同时写。数据的合理化规划等等，希望抛砖引玉，大家需要用到的时候，这篇文章可以给你帮助。
以上代码在VS2005下和64位linux运行测试通过。（可以修改我的Make文件，一般直接make即可编译）

392119301

在没人回复呢，讲解的多好啊。

zhendingl

特来学习~~

213yy

特来学习~~ 很好，谢谢! , 期待下一节