CN1737752A - 一种共享数据的管理方法 - Google Patents

Abstract

本发明公开了一种共享数据的管理方法，采用面向对象技术，建立一个类作为内存管理器，保证所述内存管理器在内存中只有一个实例，由所述内存管理器保存各个数据类的实例指针，控制所述各个数据类的读写操作。将所述各个数据类的构造函数设定为保护类型，在所述各个数据类中设定所述内存管理器取得所述各个数据类指针的函数为友元函数。本发明对内存结构的访问提供了统一的API操作，对公共内存数据进行集中管理，同时保证了数据的安全性，隐蔽性，可控性，提高了管理系统的灵活性，可扩展性，以及增强的DEBUG功能，使内存调测更加方便。

Description

一种共享数据的管理方法

技术领域

本发明涉及计算机系统领域，具体涉及一种共享数据的管理方法。

背景技术

对于大型信息系统来说，在很多情况下都是通过利用公共内存(内存池)维护大量常用数据，来提高对这些常用数据的访问性能。如一个网络级光传输网管系统，其中网元MO(Managed Object，被管对象)信息可能有数千个信息单元，电路MO信息可能达数万个信息单元，MO之间的资源占用关系更可能达到十万以上级别，而且这些数据平时可能被系统的多个模块频繁查询。尤其是在大批量数据复杂查询的情况下，对系统的负载能力和响应能力将是一个极大的考验。现有系统多采用STL(Standard Template Library，标准模板库)的直接封装来解决公共内存的问题。即将内存池的分配、调度工作交由STL模板库完成，内存池外的具体内存结构的调度工作分散由各个类来自己实现或者是作成公共结构由各调用模块自己控制。

该方案有如下缺点：

(1)由于对具体内存结构的调度分散，其安全性，可维护性都很差；

(2)由于数据基本处于暴露状态，所以数据的隐蔽性，可控性也非常差，并发控制复杂易错；

(3)由于数据由各个不同的内存结构来分别实现，所以管理系统的灵活性，可扩展性很差，每次增加数据内存结构都需要增加零散在各处的代码来实现；

(4)由于调用分散，内存数据整体上缺乏控制，导致内存数据的调试(DEBUG)工作极其困难。

发明内容

本发明的目的是提供一种共享数据的管理方法，对公共内存数据进行集中管理，同时保证数据的安全性，隐蔽性，可控性，提高管理系统的灵活性，可扩展性，以及增强的DEBUG功能，使内存调测更加方便，消除公共内存数据耦合对分布式系统架构的不良影响。

本发明的具体技术方案如下：

一种共享数据的管理方法，采用面向对象技术，建立一个类作为内存管理器，保证所述内存管理器在内存中只有一个实例，即设定该内存管理器为Singleton类，由所述内存管理器保存各个数据类的实例指针，控制所述各个数据类的读写操作。

所述方法，其中：将所述各个数据类的构造函数设定为保护类型，即Protected类型，在所述各个数据类中设定所述内存管理器取得所述各个数据类指针的函数为友元函数。

所述方法，其中：所述内存管理器通过由对象控制的配置文件，对所述各个数据类进行索引。

所述方法，其中：AutoOpen类控制文件在脱离作用域后自动关闭；AutoLock类控制互斥锁功能，使所述文件在脱离作用域后自动释放。

所述方法，其中：所述内存管理器通过内部锁机制对整个公共内存做统一的集中线程并发控制。

所述方法，其中：外围业务函数层根据业务逻辑手动对所述各个数据类进行自愈(Reload)操作。

所述方法，其中：在所述各个数据类保留有特征标志符，调试函数根据所述特征标志符来确定对所述各个数据类对象进行调试操作，所述调试操作包括数据遍历、数据查询、数据打印。

所述方法，其中：所述各个数据类提供完整的批量读写函数、单条读写函数、手动读写函数，并以不同的命名规范加以区别。

所述方法，其中：将所述各个数据类设定为STL标准模板库类。

所述方法，其中：所述各个数据类包括映射(map)类、向量(vector)类、列表(list)类、队列(queue)类、集合(set)类、堆栈(stack)类。

本发明对内存结构的访问提供了一套统一的API操作框架，从而提高了公共内存管理系统整体的性能，以及数据的安全性，隐蔽性，可控性，并抹去内存结构的相异对内存数据管理系统延展性的侵害。在编译系统支持的情况下，进一步提供对结构相同而名称相异的内存数据的统一维护。在此基础上再针对系统本身提供集中，可扩展的调试功能，使调用者只关心业务实现本身，而不必关心公共数据的存取。同时，将公共内存数据管理系统做成一个可拆卸模块，消除了其对分布式系统数据耦合的不良影响。

附图说明

图1是本发明的共享数据管理模块结构图；

图2是本发明的共享数据管理模块部署图；

图3是本发明的CGDI类UML(Unified Modeling Language)图；

图4是本发明的CGM类UML图；

图5是本发明的AutoLock和AutoOpen类UML图。

具体实施方式

下面结合附图和实施例对本发明作进一步详细说明：

这里针对STL的MAP结构统一管理给出本发明的实施过程，但其方法对其他STL容器或非STL结构也同样适用。

图1介绍了本发明的共享数据管理模块结构图，图2介绍了本发明的共享数据管理模块部署图，这套内存数据管理API以一个Singleton类CGDI(Globe Data Interface)为起点，提供统一的对内存数据包装类CGM(GlobeMap)的访问，CGDI是一个内存管理器，它保存有各个数据类的实例指针，负责生成和调度数据类CGM的读写操作，使得包装后的数据类CGM访问受控，由于CGM类的构造函数为Protected所以，如果不通过CGDI类的友元接口将无法生成或访问该数据类，CGM数据类得到了很好的数据隐蔽性。以下是CGDI类的类定义的一种模式：

class CGDI
{

    public：

         static CGDI*InstanceCGDI()；

         //(双斜杠后为说明文字)CGDI类的唯一实例化接口，该接口可以

         //使用宏来封装

    public：

         typedef std∷map＜std∷string，void*＞  NAME_POINTER_MAP；

         //容纳所有管理CGM实例从名称到指针的MAP

    public：

         template＜class FirstType，class SecondType＞

         void*GetPointer(const std∷string & strName)；

         //模板函数，由此接口根据类型和名称来获取唯一CGM指针

    protected：

            CGDI()

    //构造函数，该函数为Protected，所以无法通过NEW的方式进行实例化。

           {

                 pthread_mutex_init(&m_mtCGDI，NULL)；

                //CGDI接口的访问控制锁

                 m_memConfiger.Init(″../cfg/config.cfg″)；
        <!-- SIPO <DP n="4"> -->
        <dp n="d4"/>
    //通过内置的内存参数配置器CGMC类实例来读取文件配置内存参数

                                               }

    ～CGDI()            //析构函数，与构造函数对应，也必须是保护类型

       {

          pthread_mutex_destroy(&m_mtCGDI)；

          //销毁CGDI接口的访问控制锁

    }

    public：

         CGMC m_memConfiger；//内存配置器CGMC实例

    protected：

         static CGDI*m_pInstance；//存放本类唯一实例的指针

    protected：

         NAME_POINTER_MAP m_mapName2Pointer；

         //存放管理的CGM实例从名称类型到指针的MAP

    protected：

        static pthread_mutex_t     m_mtCGDI；  //CGDI类接口控制锁
}；
class CGMC
//包含在CGDI实例中的类对象，实现从文件中读取对公共内存参数的配置，
//并提供统一的线程安全的参数访问接口。
    {

    public：

    CGMC()  //CGMC类构造函数

      {

         pthread_mutex_init(&m_mtCGMC，NULL)；
        <!-- SIPO <DP n="5"> -->
        <dp n="d5"/>
          //CGMC接口的访问控制锁

      }

      ～CGMC() //析构函数

        {

              pthread_mutex_destroy(&m_mtCGMC)；

              //销毁CGMC接口的访问控制锁

         }
//读设置文件和初始化参数
  public：
  void Init(const std∷string& strFileName)；
  public：

    inline bool IsMemoryDebug()  //内联函数

    {

         return m_bMemoryDebug；

    }

    inline bool IsDistinguishType()

    {

         return m_bDistinguishType；

    }
    private：

    bool  m_bMemoryDebug；

    bool  m_bDistinguishType；

    private：

    pthread_mutex_t m_mtCGMC；     //这个内部锁保证了线程安
        <!-- SIPO <DP n="6"> -->
        <dp n="d6"/>
//全，操作之前类成员函数自动加锁

    }；
//这个函数通过名称和类型参数来索引需要的CGM对象。在没有索引到该
//对象的时候，我们创建一个该对象，这样可以保证只有在用到的时候CGM
//对象才会生成，从而节省内存消耗。

我们使用如下方法进行关键的CGM指针转换：

在CGDI∷GetPointer(const std∷string&strName)函数中我们可以看到这样的操作：m_mapName2Pointer.insert(NAME_POINTER_MAP∷value_type(strNameTemp，static_cast<void^*>(pCGM)))；这里将CGM类的指针pCGM显式的转换为泛型指针，然后统一存放在MAP中。

如果需要将这些已存放好的泛型指针取出来并根据MAP中保存的型别信息恢复为原指针类型可以使用包装好的宏：

#define GMAP(x，y，z)\(*static_cast<CGM<x，y>*>((CGDI∷InstanceCGDI()->CGDI∷GetPointer<x，y>\(std∷string(z)))))

下面是CGDI∷GetPointer(const std∷string& strName)函数的实现：

template＜class FirstType，class SecondType＞
void*CGDI∷GetPointer(const std∷string& strName)
{

    AutoLock autoLock(&m_mtCGDI)；

    std∷string strNameTemp＝strName；

    if(m_memConfiger.IsDistinguishType())  //该if语句调用配置器，查看是

                                           //否支持将类型作为索引条件。
        <!-- SIPO <DP n="7"> -->
        <dp n="d7"/>
    {

         strNameTemp＝strName

                    +std∷string(″+″)

                    +std∷string(typeid(FirstType).name())

                    +std∷string(″+″)

                    +std∷string(typeid(SecondType).name())；

      //得到数据类的名称

    }

    NAME_POINTER_MAP∷iterator

         itFound＝m_mapName2Pointer.find(strNameTemp)；

         //查找该数据类

    if(itFound＝＝m_mapName2Pointer.end())

    {

         _CGM_TEMPLATE*pCGM＝new_CGM_TEMPLATE；

         pCGM->SetName(strName)；

         pCGM->pCGDI＝this；
m_mapName2Pointer.insert(NAME_POINTER_MAP∷value_type(strNameTemp，

         static_cast＜void*＞(pCGM)))；

         itFound＝m_mapName2Pointer.find(strNameTemp)；

         TRACE(″Gloab Map Identifier：％s：Inserted！\n″，

                 strNameTemp.c_str())；

         TRACE(″Gloab Map Sum：％d\n″，m_mapName2Pointer.size())；

    }

    retum(itFound->second)；
        <!-- SIPO <DP n="8"> -->
        <dp n="d8"/>
}
.cc文件的部分实现样例
//静态成员
CGDI*CGDI∷m_pInstance=NULL；
pthread_mutex_tCGDI∷m_mtCGDI；
CGDI*CGDI∷InstanceCGDI()    //完成Singleton的接口实现，该函数保证
//返回该类的唯一实例。
{

    AutoLock autoLock(&m_mtCGDI)；  //利用对象析构自动加解锁

    if(！m_pInstance)

    {

    m_pInstance＝new CGDI；

    }

    return m_pInstance；
}
template＜class FirstType，class SecondType＞
class CGM：public Task
//该类直接管理装栽提供和控制访问各种STL的MAP数据结构，使用该类
//访问其内部数据时自动加锁，方便的实现了并发的控制。该类实例受
CGDI//访问的控制管理。该类为模板类，所以可以容纳各种不同种类MAP。
{

    public：

    template＜class FirstType，class SecondType＞
  friend void*CGDI∷GetPointer(const std∷string&strName)；
//这就是前面CGDI类的那个从m_mapName2Pointer成员中获取具体CGM
        <!-- SIPO <DP n="9"> -->
        <dp n="d9"/>
//指针的模板函数。这里声明为友元函数，这样CGDI类的这个函数可以直
//接访问CGM成员了，因为CGM类没有提供获取实例的静态函数接口，构
//造函数又是PROTECTED的，所以，变成只有CGDI类的GetPointer函数
//可以将CGM类实例化了，这样，CGM类的实例化和访问完全置于CGDI
//类的控制之下了。
public：

      typedef std∷map＜FirstType，SecondType＞ GLOAB_MAP；

      typedef std∷vector＜FirstType＞          FIRST_VEC；

      typedef std∷vector＜SecondType＞         SECOND_VEC；
public：
//这里提供了相当多的对CGM实际容纳的STL MAP的操作封装函数，这些
//函数会对CGM实例自身的成员锁进行锁定后再进行具体操作，所以保证
//了CGM类操作的并发安全性。

      int InsertRecords(const FirstType& First，const SecondType& Second)；

      int InsertRecords(const FIRST_VEC& vecFirst，const SECOND_VEC&
vecSecond)；

      int InsertRecords(const GLOAB_MAP& mapGloab)；

      int EraseRecords(const FirstType& First)；

      int EraseRecords(const FIRST_VEC& vecFirst)；

      int EraseRecords(const GLOAB_MAP& mapGloab)；

      int UpdateRecords(const FirstType& First，const SecondType&
Second)；

      int UpdateRecords(const FIRST_VEC& vecFirst，const
SECOND_VEC&vecSecond)；
        <!-- SIPO <DP n="10"> -->
        <dp n="d10"/>
       int UpdateRecords(const GLOAB_MAP& mapGloab)；

       SecondType GetRecords(const FirstType& First)；
int GetRecords(const FirstType& First，SecondType& Second)；

       int GetRecords(const FIRST_VEC& vecFirst，SECOND_VEC&
vecSecond)；

       int GetRecords(const FIRST_VEC& vecFirst，GLOAB_MAP&
mapGloab)；

       int Clone(GLOAB_MAP& mapGloab)；

     //提供了整个MAP的快速CLONE操作。

       int Init(const GLOAB_MAP& mapGloab)；

     //提供初始化MAP的快速操作。

        void Lock()；//提供手动对MAP加锁的操作

        void UnLock()；//提供手动对MAP解锁的操作

        int size()；
//基于性能和灵活性的考虑，下面这些小写开头的操作集成了STL原本提供
//的操作接口，他们没有对成员锁进行锁定，失去了自动的线程安全性。但可
//以通过在操作前手动调用前面的LOCK/UNLOCK函数来加解锁，从而保证
//线程安全。这样在某些特殊运用场合可以换取效率和灵活性。

    int clear()；

    int insert(const FirstType& First，const SecondType& Second)；

    int erase(const FirstType& First)；

    int erase(const typename GLOAB_MAP∷iterator& itErase)；

    SecondType get(const FirstType& First)；

    typename GLOAB_MAP∷iterator begin()；

    typename GLOAB_MAP∷iterator end()；
        <!-- SIPO <DP n="11"> -->
        <dp n="d11"/>
        typename GLOAB_MAP∷iterator find(const FirstType& First)；

public：

        void SetName(const std∷string& strMapName)；
//可以对CGM实例对象赋予唯一名称，便于调试和索引。

        std∷string Name()；

        std∷string Identifier()；//CGM实例对象名称和通过RTTI获取的
//MAP类型字符串相加后得出CGM唯一标志。

        void Reload()；             //对该CGM对象重新装载的接口，此操作用于
//在出错情况下，CGM可以通过重新载入静态数据来自愈。

        protected：
//这里同CGDI类一样，CGM类的构造和析构函数都为PROTECTED属性，
//无法用NEW的方式获取其实例。同时，他也没有象CGDI类那样提供静态
//接口，所以，只能通过声明的CGDI类友元函数GetPointer来获取实例，同
//时将自身的名称，类型信息和自身的指针在CGDI管理对象的MAP中注册，
//是管理器能够根据用户要求，方便检索到自身，同时自身保留一个管理器指
//针以便方向和管理器操作。

    CGM()//CGM类构造函数

     {

           pthread_mutex_init(&m_mtGloabMap，NULL)；

           //CGM接口的访问控制锁

     }
～CGM()    //析构函数

     {

           pthread_mutex_destroy(&m_mtGloabMap)；

           //销毁CGM接口的访问控制锁
        <!-- SIPO <DP n="12"> -->
        <dp n="d12"/>
          }

    protected：

    inline bool CheckMemDebug()//该函数调用保留的管理器的指针来使用<br/>
//管理器中的内存参数配置器来查询配置参数。

      {

           return pCGDI->m_memConfiger.IsMemoryDebug()；

       }

    protected：

       CGDI*pCGDI；  //store the pointer of manager
//通过CGDI类GetPointer函数生成实例时保留的管理器指针。

      protected：

        GLOAB_MAP         m_mapGloab；       //实际存放各类STL
//MAP的成员变量。由于是模板化的参数，所以可以存放各类MAP。

        std∷string     m_strMapName；     //MAP的名称。

      protected：

        pthread_mutex_t         m_mtGloabMap；    //CGM类控制自
//身实例并发操作线程安全的锁。
}；
template＜class FirstType，class SecondType＞
void_CGM_TEMPLATE∷SetName(const std∷string& strMapName)
{

     m_strMapName＝strMapName；
}
template＜class FirstType，class SecondType＞
std∷string_CGM_TEMPLATE∷Identifier()
        <!-- SIPO <DP n="13"> -->
        <dp n="d13"/>
{

    std∷string strTemp＝m_strMapName

                                +std∷string(″+″)

                                +std∷string(typeid(FirstType).name())

                                +std∷string(″+″)

                                +std∷string(typeid(SecondType).name())；

    return strTemp；
}
template＜class FirstType，class SecondType＞
void_CGM_TEMPLATE∷Reload()
{

    Printf(“Reload------％s\n”，Identifier().c_str())；

    //这里可以添加自定义的RELOAD操作。
}

    由AutoOpen和AutoLock两个辅助类来实现文件在脱离作用域后的自动
关闭以及互斥锁在脱离作用域后的自动释放，以增强公共内存代码的简洁性。

以下为这两个类的实现：

//Auto lock and unlock

    class AutoLock

    {

         public：

          AutoLock(pthread_mutex_t*pMutex)

          {

             m_pMutex＝pMutex；

             pthread_mutex_lock(m_pMutex)；//lock when construct
        <!-- SIPO <DP n="14"> -->
        <dp n="d14"/>
         }

    ～AutoLock()

         {

             pthread_mutex_unlock(m_pMutex)；//unlock when deconstruct

          }

       private：

       pthread_mutex_t*m_pMutex；
}；
//Auto open and close file
class AutoOpen
{

    public：
AutoOpen(FILE*& pFile，const char*pFileName，const char*pMode＝″a″)

          {

                   pFile＝fopen(pFileName，pMode)；

                   m_pFile＝pFile；

          }

    ～AutoOpen()

          {

                   if(m_pFile)

                   {

                      fclose(m_pFile)；

                   }

          }

    private：
        <!-- SIPO <DP n="15"> -->
        <dp n="d15"/>
              FILE*m_pFile；

    }；

以上对CGDI类和CGM类的实现作了详细介绍，图3介绍了本发明的CGDI类UML图，图4介绍了本发明的CGM类UML图，图5介绍了本发明的AutoLock和AutoOpen类UML图。

安全性，隐蔽性的提升：通过Singleton和友元机制保证了接口实例的唯一，无法从其他途径产生访问内存数据。CGDI和CGM通过内部的锁机制对整个公共内存做统一的集中线程并发控制，整个公共内存模块提供的API除交由用户手动控制加锁以增强效率的少数接口外都是线程安全的。外围业务函数层还可以根据业务逻辑手动对某个MAP进行Reload自愈操作，保证数据可靠性。

可控性，集中管理的提升：外围访问API由CGDI类做控制，并维护索引表，当外部通过CGDI获取所需CGM实例后，对CGM内数据的访问受到了CGM类的控制，CGM类提供了一套完整的批量读写API，单条读写API，以及为必须的外围大批量循环所准备的手动读写API，这些API以不同的命名规范区别，从名称上就能够非常容易的识别用途。

灵活性，可扩展的提升：根据编译器的能力(大部分编译器支持)，支持RTTI的编译器，公共内存管理模块可以实现对同名但容纳元素类型不同的众多MAP的统一管理，对不支持RTTI的编译器所管理的MAP则必须名称不同才能管理。对编译器的适配可以通过由对象控制的配置文件即配置器来控制。因为这里的CGM类实际是对STL MAP的一个封装泛化，所以，无论新增多少新类型的MAP，公共内存模块都无须做任何修改就可以直接象管理之前的MAP一样，管理新增的MAP内存数据。对于需要新增非MAP类型内存管理的，可以仿照CGM类添加新类型的数据类，然后交由CGDI类控制即可。

DEBUG功能的增强：在CGM模板类中保留有该MAP的特征标志符，核心API外层可增加相应DEBUG函数根据标志符参数来确定对某个CGM对象进行数据遍历，数据查询，数据打印等相关DEBUG操作。CGM和CGDI类中的每个API中也预设了一些可以从内部判断的错误情况信息打印，这些操作都可以通过相应的控制宏进行方便的开启/关闭控制。从而使得系统中所有对公共内存的DEBUG操作都得到了集中的控制和管理。

本发明技术方案带来的有益效果：

1、共享数据管理更加容易，接口简单，操作方便；

2、共享数据更加安全，可靠，提供了完整的线程安全操作API集合；

3、共享数据管理更加集中，内存数据得到了更好的封装，对外只提供一个接口，数据本身对用户完全不可见。

4、管理系统更具灵活性，可扩展性：由于CGM采用了模板类封装多样的MAP结构，提取了对MAP的公共操作作为API，所以，内存新增需要管理的MAP时，共享数据管理模块无须做任何改动，外部可以直接调用，在首次调用时生成实例，成了一个似乎与外界调用者毫不相干的，无须预先定义就可以直接使用的可以容纳无限MAP的黑盒管理容器。

下面通过具体例子来揭示该套共享数据管理模块的实际运用：

首先我们来宏封装CGDI的接口，以便获取CGDI唯一实例并调用GetPointer接口索引存放所需要MAP的CGM对象：

#define GMAP(x，y，z)\

(*static_cast<CGM<x，y>*>((CGDI∷InstanceCGDI()->CGDI∷GetPointer<

x，y>\(std∷string(z)))))

假设我们有一个MAP，定义为：

std∷map<int，set<int>>mapUser2Subnet；

我们可以这样生成一个存放该MAP的CGM类实例，并获得该CGM对象的

指针：

GMAP(int，std∷set<int>，″mapUser2Subnet″)

进一步对该操作进行简单的宏封装：

#define MAP_USER2SUBNET\

GMAP(int，std∷set<int>，″mapUser2Subnet″)

好，那么我们现在可以这样获取MAP中索引为iUserId的对应的set<int>的值了：

if(MEM_OK_CODE＝＝(iRet＝MAP_USER2SUBNET.GetRecords(

                       iUserId，setSubnetId)))

    {
//这里操作成功，我们通过iUserId获取了setSubnetId的值，进行这种操作的时
//候你不必担心存放该MAP的CGM对象还没有建立，因为及时没有建立，我
//们前面也说到，可以自动生成一个对象，只不过返回值会为空，并附有错误
//码而已。我们可以根据返回值作出判断。

    }

    else

    {

    //这里我们可以进行出错处理，现在假设我们发现错误后就重新装载

    //该CGM对象内含的MAP，以便清除错误的业务数据。我们可以这样做：

      printf(“Reload CGM is％s\n”，MAP_USER2SUBNET.Identifier().c_str())；

       //调用Identifer接口获取MAP标志。

       MAP_USER2SUBNET.Reload()；

      //调用RELOAD接口来刷新数据。

    }

其他相关的操作比如对MAP的批量查询CGM有批量查询接口，删除有删除接口，更新有更新接口等，这些接口都可以自行扩展的，重要的是由于CGDI的管理，存放相同MAP的CGM对象始终只有一份，而对这些存放着各式各样MAP的CGM对象都具有一个统一的可扩展接口，他们的并发操作都在CGDI，CGM类内部通过封锁进行了控制，所以他们都是线程安全的。

本发明的公共数据管理框架可以实现对任何STL结构(比如set，list，vector等)或非STL结构(自定义的类或结构)的数据管理，只需要将CGM类中的那个MAP成员变量替换成所需要的结构或类就可以了(相关接口可能也有少量修改，因为每个结构或类提供接口的能力是不一样的，比如MAP就没有办法提供某些vector才具有的接口)。

虽然通过参照本发明的优选实施例，已经对本发明进行了图示和描述，但本领域的普通技术人员应该明白，可以在形式上和细节上对其作各种各样的改变，而不偏离所附权利要求书所限定的本发明的精神和范围。

Claims (10)

1、一种共享数据的管理方法，其特征在于：采用面向对象技术，建立一个类作为内存管理器，保证所述内存管理器在内存中只有一个实例，由所述内存管理器保存各个数据类的实例指针，控制所述各个数据类的读写操作。

2、根据权利要求1所述的方法，其特征在于：将所述各个数据类的构造函数设定为保护类型，在所述各个数据类中设定所述内存管理器取得所述各个数据类指针的函数为友元函数。

3、根据权利要求1所述的方法，其特征在于：所述内存管理器通过由对象控制的配置文件，对所述各个数据类进行索引。

4、根据权利要求2所述的方法，其特征在于：AutoOpen类控制文件在脱离作用域后自动关闭；AutoLock类控制互斥锁功能，使所述文件在脱离作用域后自动释放。

5、根据权利要求4所述的方法，其特征在于：所述内存管理器通过内部锁机制对整个公共内存做统一的集中线程并发控制。

6、根据权利要求5所述的方法，其特征在于：外围业务函数层根据业务逻辑手动对所述各个数据类进行自愈操作。

7、根据权利要求6所述的方法，其特征在于：在所述各个数据类保留有特征标志符，调试函数根据所述特征标志符来确定对所述各个数据类对象进行调试操作，所述调试操作包括数据遍历、数据查询、数据打印。

8、根据权利要求7所述的方法，其特征在于：所述各个数据类提供完整的批量读写函数、单条读写函数、手动读写函数，并以不同的命名规范加以区别。

9、根据权利要求8所述的方法，其特征在于：将所述各个数据类设定为STL标准模板库类。

10、根据权利要求1至9所述的任一方法，其特征在于：所述各个数据类包括映射类、向量类、列表类、队列类、集合类、堆栈类。

Images