Java: Garbage Collection

A deep dive into the workings of the Java garbage collector.

Transcript

1. Garbage Collection By @karlhadwen
2. What is Automatic Garbage Collection? • Looks at heap memory • Identifying which objects are in use and which are not • Deletes unused objects or unreferenced objects • The memory used by an unreferenced object can be reclaimed • In a programming language like C, allocating and deallocating memory is a manual process. In Java, process of deallocating memory is handled automatically by the garbage collector • All objects are scanned in the marking phase • The Heap and the Garbage Collector are key parts of any Java JVM
3. Marking Before marking After marking Live object Unreferenced objects
4. Normal Deletion After normal deletion Normal deletion removes unreferenced objects leaving referenced objects and pointers to free space. Memory allocator holds a list of references of free spaces, it will then go ahead and search for a free space whenever an allocation is required. The memory allocator holds references to blocks of free space where new object can be allocated.
5. Deletion with Compacting After normal deletion with compacting It’s possible to improve performance by clustering the remaining referenced objects; basically by moving them together. This makes memory allocation easier and faster. Memory allocation holds the reference to the beginning of free space, this is then allocated sequentially. This is a great way to improve performance.
6. Why Generational Garbage Collection? • Having to mark and compact all the objects in a JVM is inefficient • As more and more objects are allocated, the list of objects grows and grows leading to longer and longer garbage collection time • Empirical analysis of applications has shown that most objects are short lived • Fewer and fewer objects remain allocated over time
7. JVM Generations • The information learned from the object allocation behaviour can be used to enhance the performance of the JVM • The heap is broken up into smaller parts or generations • The heap parts are: Young Generation, Old or Tenured Generation, and Permanent Generation
8. The Young Generation • The Young Generation is where all new objects are allocated and aged • When the young generation fills up, this causes a minor garbage collection • Minor collections can be optimised assuming a high object mortality rate • A young generation full of dead objects is collected very quickly • Some surviving objects are aged and eventually move to the old generation • All minor garbage collections are "Stop the World" events. This means that all application threads are stopped until the operation completes. Minor garbage collections are always Stop the World events • When objects disappear from this area, we say a "minor GC" has occurred
9. The Old Generation • Used to store long surviving objects, or unreachable objects • Typically, a threshold is set for young generation object and when that age is met, the object gets moved to the old generation • Eventually the old generation needs to be collected. This event is called a major garbage collection • Major garbage collection are also Stop the World events. Often a major collection is much slower because it involves all live objects. So for Responsive applications, major garbage collections should be minimised • The length of the Stop the World event for a major garbage collection is affected by the kind of garbage collector that is used for the old generation space
10. The Permanent Generation • Contains metadata required by the JVM to describe the classes and methods used in the application • The permanent generation is populated by the JVM at runtime based on classes in use by the application • In addition, Java SE library classes and methods may be stored here • Classes may get collected (unloaded) if the JVM finds they are no longer needed and space may be needed for other classes. The permanent generation is included in a full garbage collection
11. Definitions 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.
12. An Important Thing To Remember “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.” http://stackoverflow.com/questions/2129044/java-heap-terminology-young-old-and-permanent- generations
13. Storing Java Classes Java classes are stored in the permanent generation. The basic fields of a Java class there are: • Methods of a class (including the bytecodes) • Names of the classes (in the form of an object that points to a string also in the permanent generation) • Constant pool information (data read from the class file, see chapter 4 of the JVM specification for all the details) • Object arrays and type arrays associated with a class (e.g., an object array containing references to methods) • Internal objects created by the JVM (java/lang/Object or java/lang/exception for instance) • Information used for optimisation by the compilers (JITs)
14. A Visual Overview Allocations Promotion Young Generation Old Generation Permanent Generation
15. Object Allocation Eden Before marking 3 1 “from” survivor space “to” survivor space First, any new objects are allocated to the eden space. Both survivor spaces start out empty. Just allocated are created in Eden
16. Filling the Eden Space Eden Just allocated 3 1 S0 survivor space S1 survivor space Will be created in eden
17. Copying Referenced Objects Eden Unreferenced 1 S0 survivor space S1 survivor space Referenced Referenced objects are moved to the first survivor space. Unreferenced objects are deleted when the eden space is cleared.
18. Object Aging Eden Unreferenced 1 From survivor space To survivor space Referenced At the next minor GC, the same thing happens for the eden space. Unreferenced objects are deleted and referenced objects are moved to a survivor space. However, in this case, they are moved to the second survivor space (S1). In addition, objects from the last minor GC on the first survivor space (S0) have their age incremented and get moved to S1. Once all surviving objects have been moved to S1, both S0 and eden are cleared. Notice we now have differently aged object in the survivor space. 1 1 1 2 2 1 1
19. Additional Aging Eden Unreferenced 3 To survivor space From survivor space Referenced At the next minor GC, the same thing happens for the eden space. Unreferenced objects are deleted and referenced objects are moved to a survivor space. However, in this case, they are moved to the second survivor space (S1). In addition, objects from the last minor GC on the first survivor space (S0) have their age incremented and get moved to S1. Once all surviving objects have been moved to S1, both S0 and eden are cleared. Notice we now have differently aged object in the survivor space. 3 2 1 2 2 1 1
20. Promotion Eden Unreferenced 3 To survivor space From survivor space Referenced 2 8 8 1 1 9 Tenured 9 After a minor GC, when aged objects reach a certain age threshold (8 in this example) they are promoted from young generation to old generation.
21. Promotion Allocation Promotion Young Generation Old Generation As minor GCs continue to occur objects will continue to be promoted to the old generation space.
22. GC Process Summary Eden 3 To survivor space To survivor space 1 9 Tenured 9 Eventually, a major GC will be performed on the old generation which cleans up and compacts that space. Just allocated
23. Summary • Remember to subscribe for more videos. • There are no dumb questions! • Feel free to ask me questions or follow me on Twitter: @karlhadwen Important References!: http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/ index.html http://stackoverflow.com/questions/2129044/java-heap-terminology-young-old-and-permanent- generations https://blogs.oracle.com/jonthecollector/entry/presenting_the_permanent_generation