一、需求背景

1、最近項目要求高頻次地讀寫數據，數據量也不是很大，多表總共加起來在百萬條上下。

單表最大的也在25萬左右，歷史數據表因為不涉及所以不用考慮，

難點在於這個規模的熱點數據，變化非常頻繁。

數據來源於一些檢測設備的采集數據，一些大表，有可能在極短時間內（如幾秒鐘）可能大部分都會變化，

而且主程序也有一些後臺服務需要不斷輪詢、讀寫某種類型的設備，所以要求信息交互時間盡可能短。

2、之前的解決方案是把所有熱點數據，統一加載到共享內存裏邊，到也能夠支撐的住（毫秒級的），但是由於系統架構升級，之前的程序（20年前的）不能兼容。

只能重新寫一個，最先想到的是用redis，當時把所有API重寫完成後，測試發現效率不行，是的，你沒有看錯，redis也是有使用範圍的。

3、redis讀寫非常快，但是對於大批量讀寫操作我覺得支持不夠，雖然redis支持批量讀寫，但是效率還是不夠快，

對於字符串（string）類型的批量讀寫，我測試過；效率比較好的在每批次200 至 250條之間，處理20萬條數據耗時5秒左右, (PC機，8G，4核)

而對於有序集合（sorted set）類型，批量寫的操作用起來非常別扭，而且沒有修改API（如有其他方式請指教），我測試過，效率沒string類型那麽高

其他類型不適合我的業務場景，就沒考慮使用了

4、所以項目組最後決定還是用回共享內存，先決定在.net環境下使用c#的共享內存，這個功能可能使用的人不多，其實在.net4.0版本就已經集成進來了

在System.IO.MemoryMappedFile命名空間下。這個類庫讓人很無語，因為裏邊能用的只有Write、Read這2種方法，而且只是針對字節的操作，

需要非常多的類型轉換，非常麻煩！想想，只能以字節為單位去構建一個需要存放百萬級數據的內存數據庫，得多麻煩？

需要手動搞定索引功能，因為要支持各種查詢，最後花了一天的時間寫完DEMO，最後測試後發現效率並沒有很大提高，因為當時加了互斥量測試，

但是離毫秒級差得遠。這個技術點有興趣的可以了解下，園子裏有，如：https://www.cnblogs.com/zeroone/archive/2012/04/18/2454776.html

二、沒錯，第一節寫的太多了

1、最後分析，這應該是c#語言的瓶頸，c#對於這種騷操作是不那麽成熟的。

2、最後瞄來瞄去，決定使用VC開發一個dll，在裏邊封裝對內存數據的讀寫功能，然後c#調用

3、本人的C、C++不那麽熟、參考了一些實例，比如園子裏的：http://www.cnblogs.com/cwbcwb505/archive/2008/12/08/1350505.html

4、是的，你沒有看錯，2008年的，我還看到一篇更早的，看來底層開發C、C++那麽經久不衰不是沒有道理的，很多技術現在都在用

5、看看什麽是共享內存

三、開始寫代碼了

1、首先建2個控制臺項目，支持MFC，

2、先這樣：一個負責創建共享內存，初始化數據

3、再這樣：一個讀寫數據測試，最後修改

4、最後修改下圖片細節，測試一下，看看效果

5、完成了，see, 是不是很簡單呀？都會了嗎？

四、真的要貼代碼了

1、先定義個枚舉返回狀態

1 typedef enum
2 {
3     Success = 0,
4     AlreadyExists = 1,
5     Error = 2,
6     OverSize = 3
7 }enumMemory;

2、再定義個結構體用來測試

 1 typedef struct
 2 {
 3     int        TagID;
 4     char    TagName[32];
 5     int        Area;
 6     double    EngVal;
 7     double    UpdateTime;
 8     double    RawMax;
 9     double    RawMin;
10     double    RawVal;
11     char    Name[50];
12     char    Al;
13     double    ASTime;
14     char    MaskState;
15     double    AMTime;
16     char    Cf;
17     char    Tdf;
18     char    AlarmCode[32];
19 }TENG;

3、開始創建共享內存

 1     int Create(UINT size)
 2     {
 3         // Data
 4         HANDLE fileMap = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, size, “Name”);
 5 
 6         if (fileMap == NULL || fileMap == INVALID_HANDLE_VALUE)
 7             return Error;
 8 
 9         if (GetLastError() == ERROR_ALREADY_EXISTS)
10             return AlreadyExists;
11 
12         // init
13         void *mapView = MapViewOfFile(fileMap, FILE_MAP_WRITE, 0, 0, size);
14 
15         if (mapView == NULL)
16             return Error;
17         else
18             memset(mapView, 0, size);
19 
20         return Success;
21     }

4、再開始寫數據

 1     int Write(void *pDate, UINT nSize, UINT offset)
 2     {
 3         // open
 4         HANDLE fileMap = OpenFileMapping(FILE_MAP_WRITE, FALSE, “Name”);
 5 
 6         if (fileMap == NULL)
 7             return Error;
 8 
 9         // hander
10         void *mapView = MapViewOfFile(fileMap, FILE_MAP_WRITE, 0, 0, nSize);
11 
12         if (mapView == NULL)
13             return Error;
14         else
15             WriteDataPtr = mapView;
16 
17         // write
18         memcpy(mapView, pDate, nSize);
19 
20         UnmapViewOfFile(pMapView);
21         return Success;
22     }

5、開始讀數據

 1     int Read(void *pData, UINT nSize, UINT offset)
 2     {
 3         // open
 4         HANDLE fileMap = OpenFileMapping(FILE_MAP_READ, FALSE, GetTableName());
 5 
 6         if (fileMap == NULL)
 7             return Error;
 8 
 9         // hander
10         void *pMapView = MapViewOfFile(fileMap, FILE_MAP_READ, 0, 0, nSize);
11 
12         if (pMapView == NULL)
13             return Error;
14         else
15             ReadDataPtr = pMapView;
16 
17         memcpy(pData, (pMapView, nSize);
18 
19         UnmapViewOfFile(pMapView);
20         return Success;
21     }

6、OK了，不復雜，網上都有這些資料，最後我們貼上測試程序

 1 int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
 2 {
 3     int length = 100000;
 4     CEng * ceng = new CEng();
 5     DWORD dwStart = GetTickCount();
 6 
 7     for (int i = 0; i < length; i++) {
 8         TENG eng;
 9         ceng->Read(&eng, ceng->size, ceng->size * i);
10 
11         eng.EngVal = i;
12         ceng->Write(&eng, ceng->size, (i*ceng->size));
13 
14         if (i % 10000 == 0 || i == length - 1)
15             printf("正在讀寫的Eng.TagName:%s \n", eng.TagName);
16     }
17 
18     printf("總條數%d,耗時:%d 毫秒 \n", length, GetTickCount() - dwStart);
19 
20     // 驗證數據
21     TENG eng5000;
22     ceng->Read(&eng5000, ceng->size, ceng->size * 5000);
23     printf("\n驗證數據 \n");
24     printf("第5000個Eng的TagID:%d, EngVal:%lf \n", eng5000.TagID, eng5000.EngVal);
25 
26 
27     scanf_s("按任意鍵結束");
28     return 0;
29 }

7、還有寫測試程序

 1 int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
 2 {
 3     int length = 100000;
 4     CEng * ceng = new CEng();
 5     ceng->Create(ceng->size * length);
 6 
 7     DWORD dwStart = GetTickCount();
 8 
 9     for (int i = 0; i < length; i++)
10     {
11         TENG eng;
12         memset(&eng, 0, ceng->size);
13 
14         eng.TagID = i;
15         sprintf_s(eng.AlarmCode, "AlarmCode.%d", i);
16         sprintf_s(eng.TagName, "TagName.%d", i);
17 
18         if (i % 10000 == 0 || i == length - 1)
19             printf("正在寫入的Eng.TagName:%s \n", eng.TagName);
20 
21         ceng->Write(&eng, ceng->size, (i*ceng->size));
22     }
23 
24 
25     // print time
26     printf("寫入數據完畢,總條數:%d\n", length);
27     printf("初始化值共享內存區耗時:%d 毫秒 \n", GetTickCount() - dwStart);
28 
29 
30     scanf_s("按任意鍵結束");
31     return 0;
32 }

8、當然得再貼一遍啦

五、差點忘記做成DLL了

1、定義外部函數

1 extern "C" __declspec(dllexport) int ReadFromSharedMemory(TENG *pData, int nSize, int offset)
2 {
3     return ceng->Read(pData, nSize, offset);
4 }
5 
6 extern "C" __declspec(dllexport) int WriteToSharedMemory(void *pData, int nSize, int offset)
7 {
8     return ceng->Write(pData, nSize, offset);
9 }

2、好了，VC到此為止，可以去領盒飯了，c#進場

1     public class Lib
2     {
3         [DllImport("ConsoleApplication4.dll", CallingConvention = CallingConvention.Cdecl)]
4         public static extern int ReadFromSharedMemory(IntPtr pData, int nSize, int offset);
5 
6         [DllImport("ConsoleApplication4.dll", CallingConvention = CallingConvention.Cdecl)]
7         public static extern int WriteToSharedMemory(IntPtr pData, int nSize, int offset);
8     }

3、c#測試一下

 1 static void Main(string[] args)
 2         {
 3             var length = 100000;
 4             var startTime = DateTime.Now;
 5             var size = Marshal.SizeOf(typeof(TEng));
 6             var intPtrOut = Marshal.AllocHGlobal(size);
 7             var intPtrIn = Marshal.AllocHGlobal(size);
 8 
 9             for (var i = 0; i < length; i++)
10             {
11                 Lib.ReadFromSharedMemory(intPtrOut, size, size * i);
12 
13                 var eng = Marshal.PtrToStructure<TEng>(intPtrOut);
14                 eng.EngVal = i;
15 
16                 Marshal.StructureToPtr(eng, intPtrIn, true);
17                 Lib.WriteToSharedMemory(intPtrIn, size, size * i);
18 
19                 if (i % 10000 == 0)
20                     Console.WriteLine("eng.TagID:{0}", eng.TagID);
21             }
22 
23             Console.WriteLine("總條數{0},耗時:{1} 毫秒", length.ToString(),
24                 (DateTime.Now - startTime).TotalMilliseconds.ToString());
25 
26             // 驗證數據
27             var intPtr100 = Marshal.AllocHGlobal(size);
28             Lib.ReadFromSharedMemory(intPtr100, size, size * 100);
29 
30             var eng100 = Marshal.PtrToStructure<TEng>(intPtr100);
31 
32             Console.WriteLine();
33             Console.WriteLine("驗證數據");
34             Console.WriteLine("第100個Eng的TagID:{0},EngVal:{1}", eng100.TagID, eng100.EngVal);
35 
36             Console.ReadKey();
37         }

4、165毫秒，相比在VC下運行，差了一個數量級，但是，也不錯了；

因為c#環境下需要不斷的Marshal.PtrToStructure、Marshal.StructureToPtr，頻繁地把數據在托管內存俞共享內存之間搬運

是需要耗費時間的，這點有更好處理方式的請指教，

六、因為跨線程、進程，所以要考慮加入互斥量哦

1、很簡單，MFC下有現成的類CMutex，加在Write裏邊在看看效率

互斥量是需要耗費資源的，多了將進100毫秒

2、讀寫都加上互斥量試試看

又多了80多毫秒，

魚與熊掌不可兼得啊。要根據實際運用場景覺得是否加上互斥量

好了，人家51去遊玩、我卻宅家裏碼程序，可見我的趣味還是挺高的，洗澡、洗衣服、然後去吃飯、一天沒進食了，

.net環境下跨進程、高頻率讀寫數據