C++ RAII机制

前言

在写C++设计模式——单例模式的时候，在写到实例销毁时，设计的GC类是很巧妙的，而这一巧妙的设计就是根据当对象的生命周期结束时会自动调用其析构函数的，而这一巧妙的设计也是有专业的名词的——RAII。那以下将围绕RAII，全面的讲解RAII的相关知识。

什么是RAII？

RAII是Resource Acquisition Is Initialization的简称，是C++语言的一种管理资源、避免泄漏的惯用法。利用的就是C++构造的对象最终会被销毁的原则。RAII的做法是使用一个对象，在其构造时获取对应的资源，在对象生命期内控制对资源的访问，使之始终保持有效，最后在对象析构的时候，释放构造时获取的资源。

为什么要使用RAII？

上面说到RAII是用来管理资源、避免资源泄漏的方法。那么，用了这么久了，也写了这么多程序了，口头上经常会说资源，那么资源是如何定义的？在计算机系统中，资源是数量有限且对系统正常运行具有一定作用的元素。比如：网络套接字、互斥锁、文件句柄和内存等等，它们属于系统资源。由于系统的资源是有限的，就好比自然界的石油，铁矿一样，不是取之不尽，用之不竭的，所以，我们在编程使用系统资源时，都必须遵循一个步骤：

1. 申请资源；
2. 使用资源；
3. 释放资源。

第一步和第二步缺一不可，因为资源必须要申请才能使用的，使用完成以后，必须要释放，如果不释放的话，就会造成资源泄漏。

一个最简单的例子：

1. #include <iostream>

2.  

3. using namespace std;

4.  

5. int main()

6.  

7. {

8. int *testArray = new int [10];

9. // Here, you can use the array

10. delete [] testArray;

11. testArray = NULL ;

12. return 0;

13. }

我们使用new开辟的内存资源，如果我们不进行释放的话，就会造成内存泄漏。所以，在编程的时候，new和delete操作总是匹配操作的。如果总是申请资源而不释放资源，最终会导致资源全部被占用而没有资源可用的场景。但是，在实际的编程中，我们总是会各种不小心的就把释放操作忘了，就是编程的老手，在几千行代码，几万行中代码中，也会犯这种低级的错误。

再来一个例子：

1. #include <iostream>

2. using namespace std;

3.  

4. bool OperationA();

5. bool OperationB();

6.  

7. int main()

8. {

9. int *testArray = new int [10];

10.  

11. // Here, you can use the array

12. if (!OperationA())

13. {

14. // If the operation A failed, we should delete the memory

15. delete [] testArray;

16. testArray = NULL ;

17. return 0;

18. }

19.  

20. if (!OperationB())

21. {

22. // If the operation A failed, we should delete the memory

23. delete [] testArray;

24. testArray = NULL ;

25. return 0;

26. }

27.  

28. // All the operation succeed, delete the memory

29. delete [] testArray;

30. testArray = NULL ;

31. return 0;

32. }

33.  

34. bool OperationA()

35.  

36. {

37. // Do some operation, if the operate succeed, then return true, else return false

38. return false ;

39. }

40.  

41. bool OperationB()

42.  

43. {

44. // Do some operation, if the operate succeed, then return true, else return false

45. return true ;

46. }

上述这个例子的模型，在实际中是经常使用的，我们不能期待每个操作都是成功返回的，所以，每一个操作，我们需要做出判断，上述例子中，当操作失败时，然后，释放内存，返回程序。上述的代码，极度臃肿，效率下降，更可怕的是，程序的可理解性和可维护性明显降低了，当操作增多时，处理资源释放的代码就会越来越多，越来越乱。如果某一个操作发生了异常而导致释放资源的语句没有被调用，怎么办？这个时候，RAII机制就可以派上用场了。

如何使用RAII？

当我们在一个函数内部使用局部变量，当退出了这个局部变量的作用域时，这个变量也就别销毁了；当这个变量是类对象时，这个时候，就会自动调用这个类的析构函数，而这一切都是自动发生的，不要程序员显示的去调用完成。这个也太好了，RAII就是这样去完成的。由于系统的资源不具有自动释放的功能，而C++中的类具有自动调用析构函数的功能。如果把资源用类进行封装起来，对资源操作都封装在类的内部，在析构函数中进行释放资源。当定义的局部变量的生命结束时，它的析构函数就会自动的被调用，如此，就不用程序员显示的去调用释放资源的操作了。现在，我们就用RAII机制来完成上面的例子。代码如下：

1. #include <iostream>

2. using namespace std;

3.  

4. class ArrayOperation

5. {

6. public :

7. ArrayOperation()

8. {

9. m_Array = new int [10];

10. }

11.  

12. void InitArray()

13. {

14. for (int i = 0; i < 10; ++i)

15. {

16. *(m_Array + i) = i;

17. }

18. }

19.  

20. void ShowArray()

21. {

22. for (int i = 0; i <10; ++i)

23. {

24. cout<<m_Array[i]<<endl;

25. }

26. }

27.  

28. ~ArrayOperation()

29. {

30. cout<< "~ArrayOperation is called" <<endl;

31. if (m_Array != NULL )

32. {

33. delete[] m_Array; // 非常感谢益可达非常犀利的review，详细可以参加益可达在本文的评论 2014.04.13

34. m_Array = NULL ;

35. }

36. }

37.  

38. private :

39. int *m_Array;

40. };

41.  

42. bool OperationA();

43. bool OperationB();

44.  

45. int main()

46. {

47. ArrayOperation arrayOp;

48. arrayOp.InitArray();

49. arrayOp.ShowArray();

50. return 0;

51. }

上面这个例子没有多大的实际意义，只是为了说明RAII的机制问题。下面说一个具有实际意义的例子：

1. /*

2. ** FileName : RAII

3. ** Author : Jelly Young

4. ** Date : 2013/11/24

5. ** Description : More information, please go to http://www.jellythink.com

6. */

7.  

8. #include <iostream>

9. #include <windows.h>

10. #include <process.h>

11.  

12. using namespace std;

13.  

14. CRITICAL_SECTION cs;

15. int gGlobal = 0;

16.  

17. class MyLock

18. {

19. public:

20. MyLock()

21. {

22. EnterCriticalSection(&cs);

23. }

24.  

25. ~MyLock()

26. {

27. LeaveCriticalSection(&cs);

28. }

29.  

30. private:

31. MyLock( const MyLock &);

32. MyLock operator =(const MyLock &);

33. };

34.  

35. void DoComplex(MyLock &lock ) // 非常感谢益可达犀利的review 2014.04.13

36. {

37. }

38.  

39. unsigned int __stdcall ThreadFun(PVOID pv)

40. {

41. MyLock lock;

42. int *para = (int *) pv;

43.  

44. // I need the lock to do some complex thing

45. DoComplex(lock);

46.  

47. for (int i = 0; i < 10; ++i)

48. {

49. ++gGlobal;

50. cout<< "Thread " <<*para<<endl;

51. cout<<gGlobal<<endl;

52. }

53. return 0;

54. }

55.  

56. int main()

57. {

58. InitializeCriticalSection(&cs);

59.  

60. int thread1, thread2;

61. thread1 = 1;

62. thread2 = 2;

63.  

64. HANDLE handle[2];

65. handle[0] = ( HANDLE )_beginthreadex(NULL , 0, ThreadFun, ( void *)&thread1, 0, NULL );

66. handle[1] = ( HANDLE )_beginthreadex(NULL , 0, ThreadFun, ( void *)&thread2, 0, NULL );

67. WaitForMultipleObjects(2, handle, TRUE , INFINITE );

68. return 0;

69. }

这个例子可以说是实际项目的一个模型，当多个进程访问临界变量时，为了不出现错误的情况，需要对临界变量进行加锁；上面的例子就是使用的Windows的临界区域实现的加锁。但是，在使用CRITICAL_SECTION时，EnterCriticalSection和LeaveCriticalSection必须成对使用，很多时候，经常会忘了调用LeaveCriticalSection，此时就会发生死锁的现象。当我将对CRITICAL_SECTION的访问封装到MyLock类中时，之后，我只需要定义一个MyLock变量，而不必手动的去显示调用LeaveCriticalSection函数。

上述的两个例子都是RAII机制的应用，理解了上面的例子，就应该能理解了RAII机制的使用了。

使用RAII的陷阱

在使用RAII时，有些问题是需要特别注意的。容我慢慢道来。

先举个例子：

1. #include <iostream>

2. #include <windows.h>

3. #include <process.h>

4.  

5. using namespace std;

6.  

7. CRITICAL_SECTION cs;

8. int gGlobal = 0;

9.  

10. class MyLock

11. {

12. public:

13. MyLock()

14. {

15. EnterCriticalSection(&cs);

16. }

17.  

18. ~MyLock()

19. {

20. LeaveCriticalSection(&cs);

21. }

22.  

23. private:

24. //MyLock(const MyLock &);

25. MyLock operator =(const MyLock &);

26. };

27.  

28. void DoComplex(MyLock lock)

29. {

30. }

31.  

32. unsigned int __stdcall ThreadFun(PVOID pv)

33. {

34. MyLock lock;

35. int *para = (int *) pv;

36.  

37. // I need the lock to do some complex thing

38. DoComplex(lock);

39.  

40. for (int i = 0; i < 10; ++i)

41. {

42. ++gGlobal;

43. cout<< "Thread " <<*para<<endl;

44. cout<<gGlobal<<endl;

45. }

46. return 0;

47. }

48.  

49. int main()

50. {

51. InitializeCriticalSection(&cs);

52.  

53. int thread1, thread2;

54. thread1 = 1;

55. thread2 = 2;

56.  

57. HANDLE handle[2];

58. handle[0] = ( HANDLE )_beginthreadex(NULL , 0, ThreadFun, ( void*)&thread1, 0, NULL );

59. handle[1] = ( HANDLE )_beginthreadex(NULL , 0, ThreadFun, ( void*)&thread2, 0, NULL );

60. WaitForMultipleObjects(2, handle, TRUE , INFINITE );

61. return 0;

62. }

这个例子是在上个例子上的基础上进行修改的。添加了一个DoComplex函数，在线程中调用该函数，该函数很普通，但是，该函数的参数就是我们封装的类。你运行该代码，就会发现，加入了该函数，对gGlobal全局变量的访问整个就乱了。你有么有想过，这是为什么呢？网上很多讲RAII的文章，都只是说了这个问题，但是没有说为什么，在这里，我好好的分析一下这里。

由于DoComplex函数的参数使用的传值，此时就会发生值的复制，会调用类的复制构造函数，生成一个临时的对象，由于MyLock没有实现复制构造函数，所以就是使用的默认复制构造函数，然后在DoComplex中使用这个临时变量。当调用完成以后，这个临时变量的析构函数就会被调用，由于在析构函数中调用了LeaveCriticalSection，导致了提前离开了CRITICAL_SECTION，从而造成对gGlobal变量访问冲突问题，如果在MyLock类中添加以下代码，程序就又能正确运行：

1. MyLock( const MyLock & temp )

2. {

3. EnterCriticalSection(&cs);

4. }

这是因为CRITICAL_SECTION 允许多次EnterCriticalSection，但是，LeaveCriticalSection必须和EnterCriticalSection匹配才能不出现死锁的现象。

为了避免掉进了这个陷阱，同时考虑到封装的是资源，由于资源很多时候是不具备拷贝语义的，所以，在实际实现过程中，MyLock类应该如下：

1. class MyLock

2. {

3. public:

4. MyLock()

5. {

6. EnterCriticalSection(&cs);

7. }

8.  

9. ~MyLock()

10. {

11. LeaveCriticalSection(&cs);

12. }

13.  

14. private:

15. MyLock(const MyLock &);

16. MyLock operator =(const MyLock &);

17. };

这样就防止了背后的资源复制过程，让资源的一切操作都在自己的控制当中。如果要知道复制构造函数和赋值操作符的调用，可以好好的阅读一下《深度探索C++对象模型这本书》。

总结

说了这么多了，RAII的本质内容是用对象代表资源，把管理资源的任务转化为管理对象的任务，将资源的获取和释放与对象的构造和析构对应起来，从而确保在对象的生存期内资源始终有效，对象销毁时资源一定会被释放。说白了，就是拥有了对象，就拥有了资源，对象在，资源则在。所以，RAII机制是进行资源管理的有力武器，C++程序员依靠RAII写出的代码不仅简洁优雅，而且做到了异常安全。在以后的编程实际中，可以使用RAII机制，让自己的代码更漂亮。