Java heap terminology: young, old and permanent generations?

by

This seems like a common misunderstanding. In Oracle’s JVM, the permanent generation is not part of the heap. It’s a separate space for class definitions and related data. In Java 6 and earlier, interned strings were also stored in the permanent generation. In Java 7, interned strings are stored in the main object heap.

Here is a good post on permanent generation.

I like the descriptions given for each space in Oracle’s guide on JConsole:

For the HotSpot Java VM, the memory
pools for serial garbage collection
are the following.

  • Eden Space (heap): The pool from which memory is initially allocated
    for most objects.
  • Survivor Space (heap): The pool containing objects that have survived
    the garbage collection of the Eden
    space.
  • Tenured Generation (heap): The pool containing objects that have existed
    for some time in the survivor space.
  • Permanent Generation (non-heap): The pool containing all the reflective
    data of the virtual machine itself,
    such as class and method objects. With
    Java VMs that use class data sharing,
    this generation is divided into
    read-only and read-write areas.
  • Code Cache (non-heap): The HotSpot Java VM also includes a code cache,
    containing memory that is used for
    compilation and storage of native
    code.

Java uses generational garbage collection. This means that if you have an object foo (which is an instance of some class), the more garbage collection events it survives (if there are still references to it), the further it gets promoted. It starts in the young generation (which itself is divided into multiple spaces – Eden and Survivor) and would eventually end up in the tenured generation if it survived long enough.

More Related Contents:

  1. How ‘random’ is allocation of memory when I say “new Integer” in Java?
  2. How to deal with “java.lang.OutOfMemoryError: Java heap space” error?
  3. Error java.lang.OutOfMemoryError: GC overhead limit exceeded
  4. Could not reserve enough space for object heap
  5. Java 7 (JDK 7) garbage collection and documentation on G1
  6. Setting JVM heap size at runtime
  7. GC overhead limit exceeded
  8. Analyzing gc logs
  9. How does the JVM ensure that System.identityHashCode() will never change?
  10. What is the largest possible heap size with a 64-bit JVM?
  11. Size of Huge Objects directly allocated to Old Generation
  12. Java Refuses to Start – Could not reserve enough space for object heap
  13. Understanding max JVM heap size – 32bit vs 64bit
  14. Encourage the JVM to GC rather than grow the heap?
  15. Why does the JVM require warmup?
  16. Garbage collection on intern’d strings, String Pool, and perm-space
  17. How to calculate HashMap memory usage in Java?
  18. Why a sawtooth shaped graph?
  19. Is the garbage collector guaranteed to run before Out of Memory Error?
  20. Java very large heap sizes [closed]
  21. how to increase java heap memory permanently?
  22. Measuring time spent on GC
  23. how to choose the jvm heap size?
  24. Getting Java version at runtime
  25. How to find the JVM version from a program?
  26. JVM option -Xss – What does it do exactly?
  27. JFrame.dispose() vs System.exit()
  28. Setting JVM/JRE to use Windows Proxy Automatically
  29. How do I give Jenkins more heap space when it’s running as a daemon on Ubuntu?
  30. How does the JVM terminate daemon threads? or How to write daemon threads that terminate gracefully

Leave a Comment