6.1. 堆内存¶

"堆" 内存，也称为 "动态" 内存，是局部栈内存的一种替代方案。 局部内存 相当自动化。 函数被调用时，局部变量被自动分配；函数退出时，它们被自动释放。 堆内存则在各个方面都不同。 程序员显式地请求分配空间，在 Java 或 C++ 中使用 new 运算符。 这块内存 "块" 会具有特定的大小，通常根据被创建对象的大小自动确定。 那块内存（你的对象）会一直处于已分配状态，直到发生某件事使它消失。 在某些语言中（尤其是 C 和 C++），堆内存中的对象 只有 在程序员显式请求释放它时才会消失。 因此，程序员对内存拥有大得多的控制权，但也要承担更大的责任，因为现在必须主动管理内存。 在释放内存之前就丢弃指向某内存位置的所有引用，是 C/C++ 中一个重要的错误来源，而且这种情况非常常见，以至于有了一个专有名字： 内存泄漏 。 （事实上，许多用 C++ 实现的商业程序都存在内存泄漏，这最终会让它们在长期使用之后崩溃。） Java 通过使用 垃圾回收 自动处理内存释放，消除了这一错误来源。 其缺点是，垃圾回收是一个缓慢的过程，而且发生的时间不可预测。

堆内存的优点是：

• 生存期 。 由于程序员现在可以精确控制内存何时分配，就有可能先在内存中构建一个数据结构，然后把该数据结构返回给调用方。 这在局部内存下是不可能的，因为局部内存会在函数退出时被自动释放。

• 大小 。 所分配内存的大小可以控制得更加精细。 例如，可以在运行时分配一个字符串缓冲区，其大小恰好能容纳某个特定的字符串。 若使用局部内存，代码更可能声明一个大小为 1000 的缓冲区，然后听天由命。 （参见下面的 StringCopy() 例子。）

堆内存的缺点是：

• 更多工作 。 堆分配需要在代码中显式安排，这本来就是更多的工作。

• 更多 bug 。 由于现在是在代码中显式完成的，分配偶尔会出错，从而导致内存 bug。 局部内存虽然受限，但至少永远不会 出错 。

尽管如此，仍有许多问题只能靠堆内存来解决，所以事情只能如此。

下面是关于垃圾回收的一些要点。

• 垃圾回收是由 Java 虚拟机调用的一种机制，用于清除不再使用的堆内存对象。 它会移除运行中的 Java 程序不再使用的每一个对象。 这一过程的结果是释放出未使用的内存，让其他新对象能够使用那块内存。

• 在 C 和 C++ 等其他编程语言中，释放不再使用的对象和数组所占用的内存是程序员的责任。 这样做消耗程序员的时间，并增加代码的复杂度。 另一方面，垃圾回收替程序员打理内存管理，使编程变得更加容易。

• 在把对象从内存中移除之前，垃圾回收会调用该对象的 finalize() 方法，给它一个机会执行所需的任何清理工作。 如果程序员没有重写这个方法，就会调用默认的终结器方法（即 Object 类中定义的方法）。

• Java 虚拟机根据从堆中动态分配内存的大小来决定何时调用垃圾回收。 垃圾回收 很慢 ，而且难以预测。 对于有实时性能约束的程序来说，这可能是个问题。

下面是一些使对象可能被垃圾回收从堆内存中移除的情形：

1. 程序员把指向某个对象的所有引用都改成了别的东西。

2. 如果对象定义在某个代码块内部，且指向该对象的所有引用都是局部的。 当该代码块执行完毕时，局部变量被自动销毁，使得堆内存中的对象不再有任何引用。 （所以这实际上是规则 (1) 的一个特例。） 下面是一个例子：

   • Java (Generic)
   • Java

   void test(boolean found)
   {
     if (found)
     {
       // employee1 is a variable local to this if statement
       // but the Employee object is in heap memory.
       Employee employee1 = new Employee("John", 1000);
       // We can do things here with employee1, and its associated object
       Printout(employee1.name());
     }
   
     // At this point, the only reference to the created object is out of scope
     // since employee1 was local to the if statement block.
     // So the Employee object will be eligible for garbage collection.
   }
   

   void test(boolean found)
   {
     if (found)
     {
       // employee1 is a variable local to this if statement
       // but the Employee object is in heap memory.
       Employee employee1 = new Employee("John", 1000);
       // We can do things here with employee1, and its associated object
       Printout(employee1.name());
     }
   
     // At this point, the only reference to the created object is out of scope
     // since employee1 was local to the if statement block.
     // So the Employee object will be eligible for garbage collection.
   }
   

3. 假设对象 A 包含对另一个对象 B 的引用，并且 A 持有指向 B 的唯一引用。 如果 A 也符合垃圾回收的条件，那么对象 B 也将符合垃圾回收的条件。 下面是一个例子。

• Java (Generic)
• Java

// Date class to represent dates
class Date {
  int day;
  int month;
  int year;

  // Date constructor
  public Date(int d, int m, int y)
  {
    day = d; month = m; year = y;
  }
}

// An Employee class that includes a Date
class Employee {
  String name;
  Date dateOfBirth;

  // Employee constructor to initialize both name and date
  public Employee(String name , int d, int m, int y)
  {
    this.name = name;
    dateOfBirth = new Date(d, m, y);
  }
}

// Now let's test this code
class Test {

  public static void main() {
    Employee empPtr = new Employee("Sam", 3, 9, 1983);
    // Now empPtr references an object that contains a reference to a Date object

    empPtr = null; // Now the Employee object is eligible for garbage collection.
    // So its Date object will also be eligible for garbage collection
    // because nothing else points to it.
  }
}

// Date class to represent dates
class Date {
  int day;
  int month;
  int year;

  // Date constructor
  public Date(int d, int m, int y)
  {
    day = d; month = m; year = y;
  }
}

// An Employee class that includes a Date
class Employee {
  String name;
  Date dateOfBirth;

  // Employee constructor to initialize both name and date
  public Employee(String name , int d, int m, int y)
  {
    this.name = name;
    dateOfBirth = new Date(d, m, y);
  }
}

// Now let's test this code
class Test {

  public static void main() {
    Employee empPtr = new Employee("Sam", 3, 9, 1983);
    // Now empPtr references an object that contains a reference to a Date object

    empPtr = null; // Now the Employee object is eligible for garbage collection.
    // So its Date object will also be eligible for garbage collection
    // because nothing else points to it.
  }
}

Settings

Saving...
Server Error
Resubmit

在了解确切的细节之前，先来看一个堆中分配与释放的大致例子。

6.1.4. 堆示例¶

Settings

Saving...
Server Error
Resubmit

// Fraction class
class Fraction {
  int numerator, denominator;

  // Fraction constructor
  public Fraction(int num, int den) {
    numerator = num;
    denominator = den;
  }
}

// Test class
class TestHeapArray {
  static void main() {
    Fraction[] fracts;
    int i;
    int length = 100;
    
    // allocate the array
    fracts = new Fraction[length];
    // use it like an array -- in this case set them all to 22/7
    for (i = 0; i < length; i++) {
      fracts[i] = new Fraction(22, 7);
    }
    // Remove access to the array, making it garbage.
    // If the Fraction objects that were created are also garbage now.
    fracts = null;
  }
}

// Fraction class
class Fraction 
  int numerator, denominator;

  // Fraction constructor
  public Fraction(int num, int den) {
    numerator = num;
    denominator = den;
  }
}

// Test class
class TestHeapArray {
  static void main() {
    Fraction[] fracts;
    int i;
    int length = 100;
    
    // allocate the array
    fracts = new Fraction[length];
    // use it like an array -- in this case set them all to 22/7
    for (i = 0; i < length; i++) {
      fracts[i] = new Fraction(22, 7);
    }
    // Remove access to the array, making it garbage.
    // If the Fraction objects that were created are also garbage now.
    fracts = null;
  }
}