.net环境下跨进程、高频率读写数据

时间 2019-11-05

标签环境跨进高频率读写数据繁體版

原文原文链接

1、需求背景

一、最近项目要求高频次地读写数据，数据量也不是很大，多表总共加起来在百万条上下。html

单表最大的也在25万左右，历史数据表由于不涉及因此不用考虑，redis

难点在于这个规模的热点数据，变化很是频繁。数据库

数据来源于一些检测设备的采集数据，一些大表，有可能在极短期内（如几秒钟）可能大部分都会变化，c#

并且主程序也有一些后台服务须要不断轮询、读写某种类型的设备，因此要求信息交互时间尽量短。架构

二、以前的解决方案是把全部热点数据，统一加载到共享内存里边，到也可以支撑的住（毫秒级的），可是因为系统架构升级，以前的程序（20年前的）不能兼容。app

只能从新写一个，最早想到的是用redis，当时把全部API重写完成后，测试发现效率不行，是的，你没有看错，redis也是有使用范围的。函数

三、redis读写很是快，可是对于大批量读写操做我以为支持不够，虽然redis支持批量读写，可是效率仍是不够快，测试

对于字符串（string）类型的批量读写，我测试过；效率比较好的在每批次200 至 250条之间，处理20万条数据耗时5秒左右, (PC机，8G，4核)spa

而对于有序集合（sorted set）类型，批量写的操做用起来很是别扭，并且没有修改API（若有其余方式请指教），我测试过，效率没string类型那么高.net

其余类型不适合个人业务场景，就没考虑使用了

四、因此项目组最后决定仍是用回共享内存，先决定在.net环境下使用c#的共享内存，这个功能可能使用的人很少，其实在.net4.0版本就已经集成进来了

在System.IO.MemoryMappedFile命名空间下。这个类库让人很无语，由于里边能用的只有Write、Read这2种方法，并且只是针对字节的操做，

须要很是多的类型转换，很是麻烦！想一想，只能以字节为单位去构建一个须要存放百万级数据的内存数据库，得多麻烦？

须要手动搞定索引功能，由于要支持各类查询，最后花了一天的时间写完DEMO，最后测试后发现效率并无很大提升，由于当时加了互斥量测试，

可是离毫秒级差得远。这个技术点有兴趣的能够了解下，园子里有，如：https://www.cnblogs.com/zeroone/archive/2012/04/18/2454776.html

2、没错，第一节写的太多了

一、最后分析，这应该是c#语言的瓶颈，c#对于这种骚操做是不那么成熟的。

二、最后瞄来瞄去，决定使用VC开发一个dll，在里边封装对内存数据的读写功能，而后c#调用

三、本人的C、C++不那么熟、参考了一些实例，好比园子里的：http://www.cnblogs.com/cwbcwb505/archive/2008/12/08/1350505.html

四、是的，你没有看错，2008年的，我还看到一篇更早的，看来底层开发C、C++那么经久不衰不是没有道理的，不少技术如今都在用

五、看看什么是共享内存

3、开始写代码了

一、首先建2个控制台项目，支持MFC，

二、先这样：一个负责建立共享内存，初始化数据

三、再这样：一个读写数据测试，最后修改

四、最后修改下图片细节，测试一下，看看效果

五、完成了，see, 是否是很简单呀？都会了吗？

4、真的要贴代码了

一、先定义个枚举返回状态

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

二、再定义个结构体用来测试

 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;

三、开始建立共享内存

 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     }

四、再开始写数据

 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     }

五、开始读数据

 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     }

六、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 }

七、还有写测试程序

 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 }

八、固然得再贴一遍啦

5、差点忘记作成DLL了

一、定义外部函数

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 }

二、好了，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     }

三、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         }

四、165毫秒，相比在VC下运行，差了一个数量级，可是，也不错了；

由于c#环境下须要不断的Marshal.PtrToStructure、Marshal.StructureToPtr，频繁地把数据在托管内存俞共享内存之间搬运

是须要耗费时间的，这点有更好处理方式的请指教，

6、由于跨线程、进程，因此要考虑加入互斥量哦

一、很简单，MFC下有现成的类CMutex，加在Write里边在看看效率

互斥量是须要耗费资源的，多了将进100毫秒

二、读写都加上互斥量试试看

又多了80多毫秒，

鱼与熊掌不可兼得啊。要根据实际运用场景以为是否加上互斥量

好了，人家51去游玩、我却宅家里码程序，可见个人趣味仍是挺高的，洗澡、洗衣服、而后去吃饭、一天没进食了，