Running the Garbage Collector Explicitly

JVM Tutorials - Herong's Tutorial Examples

∟java.lang.Runtime Class - The JVM Instance

∟Running the Garbage Collector Explicitly

This section provides a tutorial example on how to run the Garbage Collector explicitly by calling the gc() method on the Runtime instance.

In the next test, I want to learn how to use runFinalization() and gc() methods to force the Garbage Collector to run explicitly:

/* RuntimeGarbageCollection.java
 * Copyright (c) HerongYang.com. All Rights Reserved.
 */
class RuntimeGarbageCollection {
   public static void main(String[] a) {
      java.io.PrintStream out = System.out;
      Runtime rt = Runtime.getRuntime();

      out.println("Starting the test...");
      out.println("   Total memory: " + rt.totalMemory());
      out.println("    Free memory: " + rt.freeMemory());
      out.println("    Used memory: "
         + (rt.totalMemory()-rt.freeMemory()));

      out.println("Freeing unused objects...");
      rt.runFinalization();
      rt.gc();
      out.println("   Total memory: " + rt.totalMemory());
      out.println("    Free memory: " + rt.freeMemory());
      out.println("    Used memory: "
         + (rt.totalMemory()-rt.freeMemory()));

      out.println("Allocating and discarding object...");
      bigObject();
      out.println("   Total memory: " + rt.totalMemory());
      out.println("    Free memory: " + rt.freeMemory());
      out.println("    Used memory: "
         + (rt.totalMemory()-rt.freeMemory()));

      out.println("Freeing unused objects...");
      rt.runFinalization();
      rt.gc();
      out.println("   Total memory: " + rt.totalMemory());
      out.println("    Free memory: " + rt.freeMemory());
      out.println("    Used memory: "
         + (rt.totalMemory()-rt.freeMemory()));
   }
   public static void bigObject() {
      Object o = new long[2*1024*128]; // 2 MB
      o = null;
   }
}

When executed with JVM in JDK 17, I got this result:

herong> \progra~1\java\jdk-17.0.1\bin\java RuntimeGarbageCollection.java
Starting the test...
   Total memory: 67108864
    Free memory: 49824072
    Used memory: 17284792
Freeing unused objects...
   Total memory: 10485760
    Free memory: 7714608
    Used memory: 2771152
Allocating and discarding object...
   Total memory: 10485760
    Free memory: 4326512
    Used memory: 6159248
Freeing unused objects...
   Total memory: 10485760
    Free memory: 7725784
    Used memory: 2759976

The result tells me that:

Right after the JVM started, my application and JVM used 17 MB bytes of memory.
After running the garbage collector, memory usage went down to 2.7 MB bytes.
After allocating and discard a 2 MB array object, memory usage went up to 6.2 MB. Something is wrong here. Why the JVM needs to spend 3.5 MB of memory to allocate an array of 2 MB?
After running the garbage collector gain, memory usage went down to 2.7 MB.

When executed with JVM in JDK 10, I got this result:

herong> \Progra~1\Java\jdk-10.0.1\bin\java RuntimeGarbageCollection
Starting the test...
   Total memory: 62914560
    Free memory: 60982824
    Used memory: 1931736
Freeing unused objects...
   Total memory: 8388608
    Free memory: 7463536
    Used memory: 925072
Allocating and discarding object...
   Total memory: 8388608
    Free memory: 4322392
    Used memory: 4066216
Freeing unused objects...
   Total memory: 8388608
    Free memory: 7485208
    Used memory: 903400

The result tells me that:

Right after the JVM started, my application and JVM used 1,931,736 of memory.
After running the garbage collector, memory usage went down to 925,072 bytes.
After allocating and discard a 2 MB array object, memory usage went up to 4,066,216 bytes (or 4 MB). Something is wrong here. Why the JVM needs to spend 3 MB of memory to allocate an array of 2 MB?
After running the garbage collector gain, memory usage went down to 903,400 bytes.

When executed with JVM in JDK 1.7, I got this result:

herong> \Progra~1\java\jdk1.7.0\bin\java RuntimeGarbageCollection
Starting the test...
   Total memory: 16252928
    Free memory: 15964936
    Used memory: 287992
Freeing unused objects...
   Total memory: 16318464
    Free memory: 15978808
    Used memory: 339656
Allocating and discarding object...
   Total memory: 16318464
    Free memory: 13881640
    Used memory: 2436824
Freeing unused objects...
   Total memory: 16318464
    Free memory: 16070416
    Used memory: 248048

The test result tells me that:

Right after the JVM started, my application and JVM used 287,992 bytes of memory.
After running the garbage collector, memory usage actually went up to 339,656 bytes. My guess is that calling rt.runFinalization() and rt.gc() costed more memory than what was freed up from discarded objects left from the JVM startup step.
After allocating and discard a 2 MB array object, memory usage went up to 2,436,824 bytes. The discard object was still occupying its memory.
After running the garbage collector gain, memory usage went down to 248,048 bytes, freeing up 2,188,776 bytes of memory including the discarded 2 MB array object.

Conclusion: running the garbage collector explicitly does free up memory used by discarded objects. But you don't have to do this in your application, since JVM has a separate thread running the garbage collector automatically for you.