1. Heap Memory¶

“Heap” memory, also known as “dynamic” memory, is an alternative to local stack memory. Local memory is quite automatic. Local variables are allocated automatically when a function is called, and they are deallocated automatically when the function exits. Heap memory is different in every way. The programmer explicitly requests that space be allocated, using the new operator in Java or C++. This memory “block” will be of a particular size, ususally determined automatically from the size of the object being created. That memory block (your object) continues to be allocated until something happens that makes it go away. In some languages (noteably, C and C++), an object in heap memory only goes away when the programmer explicitly requests that it be deallocated. So the programmer has much greater control of memory, but with greater responsibility since the memory must now be actively managed. Dropping all references to a memory location without deallocating it is a signficant source of errors in C/C++, and this is so common that it has a name: memory leak. (In fact, many commercial programs implemented in C++ have memory leaks, that will eventually make them crash after being used for a long time.) Java removes this source of errors by handling memory deallocation automatically, using garbage collection. The downside is that garbage collection is a slow process that happens at unpredictable times.

The advantages of heap memory are:

• Lifetime. Because the programmer now controls exactly when memory is allocated, it is possible to build a data structure in memory, and return that data structure to the caller. This was never possible with local memory, which was automatically deallocated when the function exited.

• Size. The size of allocated memory can be controlled with more detail. For example, a string buffer can be allocated at run-time that is exactly the right size to hold a particular string. With local memory, the code is more likely to declare a buffer of size 1000 and hope for the best. (See the StringCopy() example below.)

The disadvantages of heap memory are:

• More Work. Heap allocation needs to arranged for explicitly in the code, which is just more work.

• More Bugs. Because it’s now done explicitly in the code, on occasion the allocation will be done incorrectly leading to memory bugs. Local memory is constrained, but at least it’s never wrong.

Nonetheless, there are many problems that can only be solved with heap memory, so that’s the way it has to be.

The following are some important points about Garbage Collection.

• Garbage collection is a mechanism that is invoked by the Java Virtual Machine to get ride of the unused heap memory objects. It removes every object that is not being used anymore by the running Java program. The result of this process is freeing up the unused memory so other new objects can use that piece of memory.

• In other programming languages like C and C++, it is the responsibility of the programmer to take care of freeing up the memory from unused objects and arrays. Doing so consumes programmer’s time and increases code complexity. On the other hand, garbage collection makes programming easier by taking care of the memory management for the programmer.

• Before removing an object from memory, garbage collection invokes the finalize() method of that object and gives an opportunity to perform any sort of cleanup required. If the programmer does not override this method, the default finializer method will be invoked (the method defined in the Object class).

• The Java Virtual Machine invokes garbage collection based on the size of the dynamically allocated memory from the heap. Garbage collection is slow, and hard to predict. This can be a problem for programs that have real-time performance constraints.

The following are some cases that make an object subject to be removed from heap memory by garbage collection:

1. When the programmer changes all references to an object to something else.

2. If the object is defined inside a block of code, and all references to that object are local. When excecution of that block is complete, the local variables are destroyed automatically, leaving the object in heap memory without any references. (So this is really a special case of rule (1).) Here is an example

   • Java
   • Java (Generic)

   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. Assume an object A contains a reference to another object B, and A contains the only such reference to B. Object B will be eligible for garbage collection if A is also eligible for garbage collection. Here is an example.

• Java
• Java (Generic)

// 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

Before seeing the exact details, let’s look at a rough example of allocation and deallocation in the heap.

1.4. A Heap Example¶

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;
  }
}