Garbage Collection
-------------------

A summary of JVM Garbage Collection.

**Garbage collector tasks**

- Marking => traverse the stack and all nested references and mark all objects that have a reference pointing to them in the heap
- Sweeping => delete the objects not having a reference

  - By Copying: copy all live objects in a new memory portion, delete the old
  - By Compacting: delete all objects from the memory, and move around existing memory
  
**Heap memory**

- Young Generation => most java objects do not live long, will be part of generation. Fast allocation

   - Eden space => new object created here
   - Survivor => GC moves object still alive from eden to survivor space

- Old Generation => GC moves object from Young Generation for long lived object (scaveration)
  => Old Generation needs special GC treatment

- Copying objects from Young to Old generation can be expensive

**Non-Heap memory**

- Metaspace (used to be called permanent)

  - Storing:

    - Class structure
    - Method of the class
    - Constants
    - Annotations
    - Optimizations

  - Contains metadata for classes stored in Heap
  - Once objects are cleaned from heap, metaspace is cleaned too
  - Garbage collection of metaspace is special

    - Triggers when metaspace is reaching memory threshold or running out of memory
    
**Stop the world**

- Expensive process as application needs to be paused during marking
- There are alternatives

**Garbage collector implementations**

The best GC depends on your app and use case. Needs to be monitored and measured.

- Serial GC

  - Young: mark and cpy
  - Old: mark sweep compact
  - Single threaded
  - Stop the world
  - => Fine for small programs, not ideal for large program

- Parallel GC

  - Young: mark and cpy
  - Old: mark sweep compact
  - Multi-threaded
  - Stop the world (but shorter)
  - => Good for multi-core machine

- CMS GC (Concurrent Mark Sweep)

  - Young: mark and cpy
  - Old: mark sweep compact and mostly concurrent (concurrent => no requirement to stop the app)
  - Multi-threaded
  - Stop the world and mostly concurrent (sometimes will stop the world)

- G1 GC (Garbage First)

  - Divides the heap into small regions
  - Parallel, concurrent, incrementally compacting
  - Keeps track of amount of live and dead objects
  - Aim for shorter pauses
  - => Good for large memory space and high performance machines

- Z GC

  - Aims for max 10ms pause
  - Reference coloring => only works on 64 bits as it stores color into the reference
  - Sweep and copy
  - Load barriers => when reference from the heap is loaded, do some checking (remapping)
  - Multi threads
  - Concurrent

**Metrics for GC**

- Allocation rate
- Heap population
- Mutation rate (how often references are updated)
- Object life span
- Mark time (how long the GC needs to find all objects on heap)
- Compaction time (how long does it take to move objects)
- GC cycle time (how long does it take for a full cycle)

**Tools**

- jstat: jstat -gcutil
- jvisualvm