关于.net环境下跨进程、高频率读写数据的问题

freewill2001

目录
' Q2 G, Q. p/ W' u% Q( i- ?" [

• 一、需求背景
  : W0 W# v5 m  Q: o: R7 S
• 二、没错，第一节写的太多了
  
• 三、开始写代码了
  9 y, m1 [8 r5 D1 C/ b. J% Y  p
• 四、真的要贴代码了
  % n( H( h( A7 ?" q, `4 D% _$ X; q" ?
• 五、差点忘记做成DLL了
  
• 六、因为跨线程、进程，所以要考虑加入互斥量哦
  # D* R; m& V+ B: Y- V/ {" q$ ?8 K+ M

一、需求背景

1、最近项目要求高频次地读写数据，数据量也不是很大，多表总共加起来在百万条上下。
2 R% T: Z3 n' t, k* e6 V7 d单表最大的也在25万左右，历史数据表因为不涉及所以不用考虑，
难点在于这个规模的热点数据，变化非常频繁。
数据来源于一些检测设备的采集数据，一些大表，有可能在极短时间内（如几秒钟）可能大部分都会变化，
# s3 S# Q$ v% l% ?2 S而且主程序也有一些后台服务需要不断轮询、读写某种类型的设备，所以要求信息交互时间尽可能短。
5 s: m3 @7 q& r% P: Z! S$ f2、之前的解决方案是把所有热点数据，统一加载到共享内存里边，到也能够支撑的住（毫秒级的），但是由于系统架构升级，之前的程序（20年前的）不能兼容。
只能重新写一个，最先想到的是用redis，当时把所有API重写完成后，测试发现效率不行，是的，你没有看错，redis也是有使用范围的。
3、redis读写非常快，但是对于大批量读写操作我觉得支持不够，虽然redis支持批量读写，但是效率还是不够快，
3 M) W' ~3 b* o+ n7 K4 ^; V对于字符串（string）类型的批量读写，我测试过；效率比较好的在每批次200 至 250条之间，处理20万条数据耗时5秒左右, (PC机，8G，4核)
而对于有序集合（sorted set）类型，批量写的操作用起来非常别扭，而且没有修改API（如有其他方式请指教），我测试过，效率没string类型那么高
1 m9 V) G8 N. o( |9 j5 N2 x其他类型不适合我的业务场景，就没考虑使用了
$ o8 k1 n6 ?) Y5 P- H* D4、所以项目组最后决定还是用回共享内存，先决定在.net环境下使用c#的共享内存，这个功能可能使用的人不多，其实在.net4.0版本就已经集成进来了
在System.IO.MemoryMappedFile命名空间下。这个类库让人很无语，因为里边能用的只有Write、Read这2种方法，而且只是针对字节的操作，
' S: q2 H$ U* r4 H$ J6 {4 \  X3 a需要非常多的类型转换，非常麻烦！想想，只能以字节为单位去构建一个需要存放百万级数据的内存数据库，得多麻烦？
3 q7 j, H. A3 @/ _需要手动搞定索引功能，因为要支持各种查询，最后花了一天的时间写完DEMO，最后测试后发现效率并没有很大提高，因为当时加了互斥量测试，
6 v& H8 t6 G; [; s但是离毫秒级差得远。这个技术点有兴趣的可以了解下，园子里有，如：https://www.cnblogs.com/zeroone/archive/2012/04/18/2454776.html

二、没错，第一节写的太多了
* O( ~2 X7 W: n. T1 @" J9 j
1、最后分析，这应该是c#语言的瓶颈，c#对于这种骚操作是不那么成熟的。
! e  u6 v; R! n% s( Z7 x$ L! a2、最后瞄来瞄去，决定使用VC开发一个dll，在里边封装对内存数据的读写功能，然后c#调用
: h+ \) W1 V+ G/ k9 w3、本人的C、C++不那么熟、参考了一些实例，比如园子里的：http://www.cnblogs.com/cwbcwb505/archive/2008/12/08/1350505.html
4、是的，你没有看错，2008年的，我还看到一篇更早的，看来底层开发C、C++那么经久不衰不是没有道理的，很多技术现在都在用
5、看看什么是共享内存
8 G$ O" S0 `! k* J1 g

8 A, \, Y, C" L$ w三、开始写代码了

1、首先建2个控制台项目，支持MFC，
2、先这样：一个负责创建共享内存，初始化数据
! T0 O- `% Y! f, z% U5 w7 }4 k8 ~: R3、再这样：一个读写数据测试，最后修改
4、最后修改下图片细节，测试一下，看看效果
  _6 [1 a% M& _1 j6 v

, L) w" P& Z2 T# _% L  @% p3 [# g5、完成了，see, 是不是很简单呀？都会了吗？

# e0 V: N6 n+ d4 F% L' P" {四、真的要贴代码了

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

1. typedef enum{    Success = 0,    AlreadyExists = 1,    Error = 2,    OverSize = 3}enumMemory;

复制代码

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

1. typedef struct{    int        TagID;    char    TagName[32];    int        Area;    double    EngVal;    double    UpdateTime;    double    RawMax;    double    RawMin;    double    RawVal;    char    Name[50];    char    Al;    double    ASTime;    char    MaskState;    double    AMTime;    char    Cf;    char    Tdf;    char    AlarmCode[32];}TENG;

复制代码

3、开始创建共享内存

1. int Create(UINT size)    {        // Data        HANDLE fileMap = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, size, “Name”);        if (fileMap == NULL || fileMap == INVALID_HANDLE_VALUE)            return Error;        if (GetLastError() == ERROR_ALREADY_EXISTS)            return AlreadyExists;        // init        void *mapView = MapViewOfFile(fileMap, FILE_MAP_WRITE, 0, 0, size);        if (mapView == NULL)            return Error;        else            memset(mapView, 0, size);        return Success;    }

复制代码

4、再开始写数据

1. int Write(void *pDate, UINT nSize, UINT offset)    {        // open        HANDLE fileMap = OpenFileMapping(FILE_MAP_WRITE, FALSE, “Name”);        if (fileMap == NULL)            return Error;        // hander        void *mapView = MapViewOfFile(fileMap, FILE_MAP_WRITE, 0, 0, nSize);        if (mapView == NULL)            return Error;        else            WriteDataPtr = mapView;        // write        memcpy(mapView, pDate, nSize);        UnmapViewOfFile(pMapView);        return Success;    }

复制代码

5、开始读数据

1. int Read(void *pData, UINT nSize, UINT offset)    {        // open        HANDLE fileMap = OpenFileMapping(FILE_MAP_READ, FALSE, GetTableName());        if (fileMap == NULL)            return Error;        // hander        void *pMapView = MapViewOfFile(fileMap, FILE_MAP_READ, 0, 0, nSize);        if (pMapView == NULL)            return Error;        else            ReadDataPtr = pMapView;        memcpy(pData, (pMapView, nSize);        UnmapViewOfFile(pMapView);        return Success;    }

复制代码

6、OK了，不复杂，网上都有这些资料，最后我们贴上测试程序

1. int _tmain(int argc, TCHAR* argv[], TCHAR* envp[]){    int length = 100000;    CEng * ceng = new CEng();    DWORD dwStart = GetTickCount();    for (int i = 0; i < length; i++) {        TENG eng;        ceng->Read(&eng, ceng->size, ceng->size * i);        eng.EngVal = i;        ceng->Write(&eng, ceng->size, (i*ceng->size));        if (i % 10000 == 0 || i == length - 1)            printf("正在读写的Eng.TagName:%s \n", eng.TagName);    }    printf("总条数%d,耗时:%d 毫秒 \n", length, GetTickCount() - dwStart);    // 验证数据    TENG eng5000;    ceng->Read(&eng5000, ceng->size, ceng->size * 5000);    printf("\n验证数据 \n");    printf("第5000个Eng的TagID:%d, EngVal:%lf \n", eng5000.TagID, eng5000.EngVal);    scanf_s("按任意键结束");    return 0;}

复制代码

7、还有写测试程序

1. int _tmain(int argc, TCHAR* argv[], TCHAR* envp[]){    int length = 100000;    CEng * ceng = new CEng();    ceng->Create(ceng->size * length);    DWORD dwStart = GetTickCount();    for (int i = 0; i < length; i++)    {        TENG eng;        memset(&eng, 0, ceng->size);        eng.TagID = i;        sprintf_s(eng.AlarmCode, "AlarmCode.%d", i);        sprintf_s(eng.TagName, "TagName.%d", i);        if (i % 10000 == 0 || i == length - 1)            printf("正在写入的Eng.TagName:%s \n", eng.TagName);        ceng->Write(&eng, ceng->size, (i*ceng->size));    }    // print time    printf("写入数据完毕,总条数:%d\n", length);    printf("初始化值共享内存区耗时:%d 毫秒 \n", GetTickCount() - dwStart);    scanf_s("按任意键结束");    return 0;}

复制代码

8、当然得再贴一遍啦

. Q+ s8 p/ a% y: l/ f! U
1 L2 y! H5 b5 Z1 ?/ e8 M3 ^五、差点忘记做成DLL了
8 ?/ y/ X/ `9 z3 E& g& {
1、定义外部函数

1. extern "C" __declspec(dllexport) int ReadFromSharedMemory(TENG *pData, int nSize, int offset){    return ceng->Read(pData, nSize, offset);}extern "C" __declspec(dllexport) int WriteToSharedMemory(void *pData, int nSize, int offset){    return ceng->Write(pData, nSize, offset);}

复制代码

2、好了，VC到此为止，可以去领盒饭了，c#进场

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

复制代码

3、c#测试一下

1. static void Main(string[] args)        {            var length = 100000;            var startTime = DateTime.Now;            var size = Marshal.SizeOf(typeof(TEng));            var intPtrOut = Marshal.AllocHGlobal(size);            var intPtrIn = Marshal.AllocHGlobal(size);            for (var i = 0; i < length; i++)            {                Lib.ReadFromSharedMemory(intPtrOut, size, size * i);                var eng = Marshal.PtrToStructure(intPtrOut);                eng.EngVal = i;                Marshal.StructureToPtr(eng, intPtrIn, true);                Lib.WriteToSharedMemory(intPtrIn, size, size * i);                if (i % 10000 == 0)                    Console.WriteLine("eng.TagID:{0}", eng.TagID);            }            Console.WriteLine("总条数{0},耗时:{1} 毫秒", length.ToString(),                (DateTime.Now - startTime).TotalMilliseconds.ToString());            // 验证数据            var intPtr100 = Marshal.AllocHGlobal(size);            Lib.ReadFromSharedMemory(intPtr100, size, size * 100);            var eng100 = Marshal.PtrToStructure(intPtr100);            Console.WriteLine();            Console.WriteLine("验证数据");            Console.WriteLine("第100个Eng的TagID:{0},EngVal:{1}", eng100.TagID, eng100.EngVal);            Console.ReadKey();        }

复制代码

' g* c# i" A$ [1 @; _" [4、165毫秒，相比在VC下运行，差了一个数量级，但是，也不错了；
因为c#环境下需要不断的Marshal.PtrToStructure、Marshal.StructureToPtr，频繁地把数据在托管内存俞共享内存之间搬运
9 P: ]! l5 y4 J) r; W; e是需要耗费时间的，这点有更好处理方式的请指教，

1 g- n* @6 O( C3 O) }& k4 l六、因为跨线程、进程，所以要考虑加入互斥量哦
3 Q) ?! f6 ^$ E: A
1、很简单，MFC下有现成的类CMutex，加在Write里边在看看效率

互斥量是需要耗费资源的，多了将进100毫秒
2、读写都加上互斥量试试看
, H1 h1 E" W& C: O

/ D, ]$ h9 l' C4 Y又多了80多毫秒，
5 f; b$ Y1 w3 o, d/ t1 S! _2 ?鱼与熊掌不可兼得啊。要根据实际运用场景觉得是否加上互斥量
好了，人家51去游玩、我却宅家里码程序，可见我的趣味还是挺高的，洗澡、洗衣服、然后去吃饭、一天没进食了，
以上就是.net环境下跨进程、高频率读写数据的详细内容，更多关于.net跨进程高频率读写数据的资料请关注脚本之家其它相关文章！
" ]1 L% k4 Y" W, I% g/ s8 i* @
来源：http://www.jb51.net/article/213616.htm
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！