资源管理技术 RAII

1.什么是RAII技术
RAII（Resource Acquisition Is Initiialization）是一种利用对象生命周期来控制程序资源(如内存，文件句柄，网络连接，互斥量)的简单技术。
RAII的一般做法是这样的:在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。
借此，我们实际上把管理一份资源的责任托管给一个对象。这种做法有两大好处:

  不需要显式地释放资源。当产生异常、回滚等现象时，RAII可以正确地释放掉资源。
  采用这种方式，对象所需的资源在其生命期内始终保持有效。

2.
RAII的好处在于它提供了一种资源自动管理的方式，当产生异常、回滚等现象时，RAII可以正确地释放掉资源。
举个常见的例子：
void Func()
{
 FILE *fp;
 char* filename = "test.txt";
 if((fp=fopen(filename,"r"))==NULL)
 {
  printf("not open");
  exit(0);
 }
 ... // 如果 在使用fp指针时产生异常 并退出
  // 那么 fp文件就没有正常关闭
  
  fclose(fp);
}
在资源的获取到释放之间，我们往往需要使用资源，但常常一些不可预计的异常是在使用过程中产生，就会使资源的释放环节没有得到执行。

此时，就可以让RAII惯用法大显身手了。

 

RAII的实现原理很简单，利用stack上的临时对象生命期是程序自动管理的这一特点，将我们的资源释放操作封装在一个临时对象中。

具体示例代码如下：
class Resource{};
class RAII{
public:
    RAII(Resource* aResource):r_(aResource){} //获取资源
    ~RAII() {delete r_;} //释放资源
    Resource* get()    {return r_ ;} //访问资源
private:
    Resource* r_;
};
比如文件操作的例子，我们的RAII临时对象类就可以写成：
class FileRAII{
public:
    FileRAII(FILE* aFile):file_(aFile){}
    ~FileRAII() { fclose(file_); }//在析构函数中进行文件关闭
    FILE* get() {return file_;}
private:
    FILE* file_;
};
则上面这个打开文件的例子就可以用RAII改写为：
void Func()
{
 FILE *fp;
 char* filename = "test.txt";
 if((fp=fopen(filename,"r"))==NULL)
 {
  printf("not open");
  exit(0);
 }
 FileRAII fileRAII(fp);
 ... // 如果 在使用fp指针时产生异常 并退出
  // 那么 fileRAII在栈展开过程中会被自动释放，析构函数也就会自动地将fp关闭
  
  // 即使所有代码是都正确执行了，也无需手动释放fp，fileRAII它的生命期在此结束时，它的析构函数会自动执行！ 
}
这就是RAII的魅力，它免除了对需要谨慎使用资源时而产生的大量维护代码。在保证资源正确处理的情况下，还使得代码的可读性也提高了不少。

创建自己的RAII类

一般情况下，RAII临时对象不允许复制和赋值，当然更不允许在heap上创建，所以先写下一个RAII的base类，使子类私有继承Base类来禁用这些操作：
class Uncopyable{
protected:                       //允许derived对象构造和析构
 Uncopyable(){}
 ~Uncopyable(){}
private:
 Uncopyable(const Uncopyable&);  //但阻止copying
 Uncopyable& operator=(const Uncopyable&);
};

当我们要写自己的RAII类时就可以直接继承该类的实现：
template<class T>class RaiiResource:private Uncopyable
{
public:
explicit RaiiResource(T * aResource):pr(aResource){}  //获取资源
~RaiiResource() {delete pr;} //释放资源
T* get() {return pr;} //访问资源
private:
T* pr;
};

将RaiiResource类做成模板类，这样就可以将class类型放入其中。另外， RaiiResource可以根据不同资源类型的释放形式来定义不同的析构函数。

由于不能使用该类的指针，所以使用虚函数是没有意义的。

注：自己写的RAII类并没有经过大量的实践，可能存在问题，请三思而慎用。这里只是记录下自己的实现想法。

3.实战应用

.1 scope lock (局部锁技术) （参见 ACE  ACE_Gaurd 模板类的实现）

     在很多时候，为了实现多线程之间的数据同步，我们会使用到 mutex,critical section,event,singal 等技术。但在使用过程中，由于各种原因，有时候，我们会遇到一个问题：
由于忘记释放（Unlock）锁，产生死锁现象。

     采用RAII 就可以很好的解决这个问题,使用着不必担心释放锁的问题. 示例代码如下:

     My_scope_lock 为实现 局部锁的模板类.

     LockType 抽象代表具体的锁类 .如 基于 mutex 实现 mutex_lock 类.

template<class LockType>
class My_scope_lock
{
   public:
   My_scope_lock(LockType& _lock):m_lock(_lock)
   {
         m_lock.occupy();
    }
   ~My_scope_lock()
   {
        m_lock.relase();
   }
   protected:
   LockType    m_lock;
};

开发中使用示例:

  假设对Data 类中的数据操作需要 互斥控制.
class Data
{
  public:
  Data();
  ~Data();
  bool getdata();
  bool savedata();
  bool update();
  private:
  mutex_lock  m_mutex_lock;
};
在Update 方法中使用了局部锁 (scope_lock) .在Update 函数中我们声明了 My_Scope_Lock 局部变量.在My_Scope_Lock  的构造函数中我们
已经下达了对数据加以了保护的"命令". 大家都知道,当函数推出的时候,局部变量会自动被回收,也就是说 My_Scope_Lock 的析构函数会被自动的调用,
即自动释放锁.
这样永远都不会出现死锁现象.如果不使用局部锁技术,我们就要在函数的每一个出口处去释放锁,这样很容易出错,且代码不优雅不易维护.
bool class Data::Update()
{
  My_scope_lock l_lock(m_mutex_lock);
 
  if()
  {
     return false;
  }
  else
  {
    // execute
  }
  return true;
}

 我们可以根据上面的这个例子类推出好多这样例子. 如,读写文件的时候,很容易忘记关闭文件,如果借用 RAII

技术,就可以规避这种错误.再如对数据库的访问,忘记断开数据库连接等等,都可以借助RAII 技术也解决.

 
.2 资源释放   

     资源释放方面，RAII有其特有的优势：如果使用scope(exit)的话，每个资源分配之后都需要用一个scope(exit)跟在后面保护起来；
而如果用RAII的话，一个资源申请就对应于一个RAII对象的构造，释放工作则被隐藏在对象的析构函数中，从而使代码主干保持了清爽。

   尤其,当我们 使用 exception 异常处理机制时,RAII 会给我们带来很大的帮助.

 

3.请记住：

为防止资源泄露，请使用RAII对象，它们在构造函数中获得资源并在析构函数中释放资源。

两个常被使用的RAII class 分别是tr1::shared_ptr和auto_ptr。前面通常是较佳选择，因为其copy行为比较直观。若选择auto_ptr，复制动作会使它(被复制物)指向NULL.。

复制RAII对象必须一并复制它所管理的资源，所以资源的copying行为决定RAII对象的copying行为(reference counting)。不过其他行为也都可能被实现。

APIs往往要求访问原始资源(raw resources),所以每一个RAII class应该提供一个"取得其所管理之资源"的办法。

对原始资源的访问可能经由显示转换或隐式转换。一般而言显示转换比较安全，但隐式转换对客户比较方便。

普通而常见的RAII class copying 行为是：抑制copying、施行引用计数法