Does GC release back memory to OS?

by

The HotSpot JVM does release memory back to the OS, but does so reluctantly since resizing the heap is expensive and it is assumed that if you needed that heap once you’ll need it again.

In general shrinking ability and behavior depends on the chosen garbage collector, the JVM version since shrinking capability was often introduced in later versions long after the GC itself was added. Some collectors may also require additional options to be passed to opt into shrinking. And some most likely never will support it, e.g. EpsilonGC.
So if heap shrinking is desired it should be tested for a particular JVM version and GC configuration.

JDK 8 and earlier

There are no explicit options for prompt memory reclamation in these versions but you can make the GC more aggressive in general by setting -XX:GCTimeRatio=19 -XX:MinHeapFreeRatio=20 -XX:MaxHeapFreeRatio=30 which will allow it to spend more CPU time on collecting and constrain the amount of allocated-but-unused heap memory after a GC cycle.

If you’re using a concurrent collector you can also set -XX:InitiatingHeapOccupancyPercent=N with N to some low value to let the GC run concurrent collections almost continuously, which will consume even more CPU cycles but shrink the heap sooner. This generally is not a good idea, but on some types of machines with lots of spare CPU cores but short on memory it can make sense.

If you’re using G1GC note that it only gained the ability to yield back unused chunks in the middle of the heap with jdk8u20, earlier versions were only able to return chunks at the end of the heap which put significant limits on how much could be reclaimed.

If you’re using a collector with a default pause time goal (e.g. CMS or G1) you can also relax that goal to place fewer constraints on the collector, or you can switch go the parallel collector to prioritize footprint over pause times.

To verify that shrinking occurs or to diagnose why a GC decides not to shrink you can use GC Logging with -XX:+PrintAdaptiveSizePolicy may also provide insight, e.g. when the JVM tries to use more memory for the young generation to meet some goals.

JDK 9

Added the -XX:-ShrinkHeapInSteps option which can be be used to apply the shrinking caused by the options mentioned in the previous section more aggressively. Relevant OpenJDK bug.

For logging -XX:+PrintAdaptiveSizePolicy has been replaced with -Xlog:gc+ergo

JDK 12

Introduced the option to enable prompt memory release for G1GC via the G1PeriodicGCInterval (JEP 346), again at the expense of some additional CPU. The JEP also mentions similar features in Shenandoah and the OpenJ9 VM.

JDK 13

Adds similar behavior for ZGC, in this case it is enabled by default.

More Related Contents:

  1. How ‘random’ is allocation of memory when I say “new Integer” in Java?
  2. How to monitor Java memory usage?
  3. Circular References in Java
  4. What is the actual memory place for static variables?
  5. kubernetes pod memory – java gc logs
  6. Size of Huge Objects directly allocated to Old Generation
  7. Java still uses system memory after deallocation of objects and garbage collection
  8. Thread Caching and Java Memory model
  9. How to calculate HashMap memory usage in Java?
  10. How to read a verbose:GC output?
  11. How can I read a large text file line by line using Java?
  12. How do I discover memory usage of my application in Android?
  13. Why is it bad practice to call System.gc()?
  14. When is the finalize() method called in Java?
  15. Calculate size of Object in Java [duplicate]
  16. Does assigning objects to null in Java impact garbage collection?
  17. Read large files in Java
  18. When will a string be garbage collected in java
  19. Garbage collector in java – set an object null
  20. In Java, when does an object become unreachable?
  21. How can I avoid garbage collection delays in Java games? (Best Practices) [closed]
  22. Can I set Java max heap size for running from a jar file?
  23. When Is The Object Eligible For Garbage Collection?
  24. JVM sending back memory to OS [duplicate]
  25. Why does the JVM require warmup?
  26. How to make a long time Full GC in Java manually
  27. Default garbage collector for Java 8
  28. Measuring time spent on GC
  29. When does Java’s garbage collection free a memory allocation?
  30. How to load tiles from a large bitmap in Android?

Leave a Comment