垃圾回收系列（1）：没有GC，世界将会怎样

最新推荐文章于 2024-09-28 23:06:45 发布

meander

最新推荐文章于 2024-09-28 23:06:45 发布

阅读量525

点赞数

分类专栏： DoNet Framework 文章标签： delete string lisp 语言 service vector

DoNet Framework 专栏收录该内容

37 篇文章 0 订阅

订阅专栏

最近在公司内部做了一次关于垃圾回收的讲座，我打算用几篇文章把讲座的内容整理出来，供大家参考。在开始之前，我们有必要稍微复习一下内存分配的主要方式，大多数主流语言都支持三种内存分配方式：

1. 静态分配：静态变量和全局变量的分配形式
2. 自动分配：在栈中为局部变量分配内存的方法
3. 动态分配：在堆中动态分配内存空间以存储数据的方式

如何管理堆对象的生命周期，正是我们要探讨的话题。从面向对象的角度来看，每个对象的生命周期应该由自己管理，也就是说，作为一个对象，它知道自己什么时候被创建，什么时候被销毁。然而事实上却不是这样，因为对象之间有相互引用关系，所以对象往往不知道自己什么时候可以宣告死亡，如果对象释放太早，会造成“悬空引用”问题；如果释放的太晚或者不释放，又会造成内存泄露问题。

在C/C++中提供了显式的内存管理方案，可以用malloc/new来显式分配一段内存，而当这段内存不再需要的时候，使用free/delete把它返回给系统，看下面这段代码：

int 
main()

{

    string *ptr = new 
string;



    // do something



    
delete 
ptr;

}

这个过程非常的自然清晰，不是吗？在使用之前用new分配一段内存，使用完毕后再用delete销毁。可惜的是，现实世界中的代码不都是这么简单，开发人员会由于各种各样的原因，而忘记释放内存，或者释放内存不正确，从而导致内存泄露。下面是一个典型的内存泄露示例：

void 
service(int 
n, char
** names)

{

    for
(int 
i=0; i< n; i++)

    {

        char
* buf = (char
*) malloc(strlen(names[i]));



        strncpy(buf,names[i], strlen(names[i]));

    }    

}

显然这里释放内存的工作应该由开发人员完成，但开发人员却忘记了调用free()。

void 
service()

{

    Node* x = new 
Node("mid-autumn"
);

    Node* ptr = x;

    delete 
x;

    cout << ptr->data << endl;     

}

这段代码的问题在于不正确的调用了delete，提前释放了x的内存而导致最后一句ptr->data出错。麻烦的事情远不止这些，继续看下面这段代码：

int 
main()

{

    string *ptr = new 
string[100];



    // do something

    

    
delete 
ptr;

}

这段代码中看起来很美，使用new来为100个string对象分配内存，最后也使用了delete来销毁，但不幸的是这段代码仍然不正确，这里为 100个string对象分配的对象，最后可能有99个string未必删除，原因在于没有使用相同形式的new和delete，正确的应该为：

int 
main()

{

    string *ptr = new 
string[100];



    // do something

    

    
delete 
[] ptr;

}

注意到最后那个[]了吗？简单的说，在调用new时使用了[]，在调用delete时也要使用[]。但这条规则又不像我们说的这么简单，有了typedef，在调用new时可能没有使用[]，但是在调用delete时却要使用[]，如下面这段代码：

typedef 
string address[4];



int 
main()

{

    string *ptr = new 
address;



    // do something

    

    
delete 
[] ptr;

}

噩梦还没有到此结束，如果我们有两个类型Array和NamedArray，其中NamedArray公有继承于Array，如下面的代码所示：

template
<class 
T>

class 
Array

 {

    public
:

        Array(int 
lowBound, int 
highBound);

        ~Array();

    private
:

        vector<T> data;

        size_t size;

        int 
lBound, int 
hBound;

};



template
<class 
T>

class 
NamedArray : public 
Array<T> 

{

    public
:

        NamedArray(int 
lowBound, int 
highBound, const 
string& name);

    private
:

        string* aName;   

};

开发人员在使用上面两个类型时，写了这样一段代码：

int 
main()

{

   NamedArray<int
> *pna = new 
NamedArray<int
>(10,20,"Users"
);

   Array<int
> *pa;

   pa = pna;



   // do something



   
delete 
pa;

}

看出问题所在了吗？最后一行调用delete并不能释放aname所占用的内存，原因在于Array类型的析构函数~Array()并没有被声明为virtual！所以父类的析构函数并没有表现出多态的特性。

通过上面的几个例子，想必大家已经体会到了显式管理内存的困难，于是在C++里出现了智能指针的概念，来减少开发人员手工管理内存出错的可能性，最常见的如STL中的std::auto_ptr，本质上它也是个普通的指针，只不过std::auto_ptr会在析构的时候调用 delete 操作符来自动释放所包含的对象。

int 
main()

{

   auto_ptr<int
> ptr(new int
(42));

   

   cout << *ptr << endl;



   // 不再需要delete了


}

在大名鼎鼎的Boost C++库中更是包含了很多的智能指针，可用于各种情况，如作用域指针boost::scoped_ptr，共享指针boost::shared_ptr等等，如下代码所示：

#include 
<boost/shared_ptr.hpp> 


#include 
<vector> 




int 
main() 

{ 

  std::vector<boost::shared_ptr<int
> > v; 

  v.push_back(boost::shared_ptr<int
>(new int
(1))); 

  v.push_back(boost::shared_ptr<int
>(new int
(2))); 

}

对象生命周期管理，除了使用显式管理方案之后，还有一种机制就是隐式管理，即垃圾回收（Garbage Collection，简称为GC），最早出现于世界第二元老语言Lisp中，Jean E. Sammet曾经说过，Lisp语言最长久的贡献之一是一个非语言特征，即代表了系统自动处理内存的方法的术语极其技术——垃圾回收（GC，Garbage Collection）。而现在很多平台和语言都支持垃圾回收机制，如JVM、CLR、Python等。在下一篇文章中将会介绍几种经典的垃圾回收算法。