GC Basic Algorithm

Theory

Most GCs follow the theory of generational collection, which is based on the following two:

• Week generational hypothesis: Most of the objects are short-living.
• Strong generational hypothesis: The more times an object survives GC, the harder it is to die.

Mark-Sweep

• After the marking phase has been completed all space occupied by unvisited objects is considered free and can thus be reused to allocate new objects.
• There may exist plenty of free regions but if no single region is large enough to accommodate the allocation, the allocation is still going to fail.

Mark-Copy

• To avoid excessive fragmentation, it splits the space into two parts and copies the surviving objects into empty parts.
• The disadvantage is the need for one more memory region, which should be large enough to accommodate survived objects.

Mark-Compact

• Like mark-copy, it doesn't require another space to copy but a more complex operation to move the object.

Reachability analysis

First, GC defines some specific objects as Garbage Collection Roots. Examples of such GC roots are:

• Local variable and input parameters of the currently executing methods
• Active threads
• Static field of the loaded classes
• JNI references

Next, GC traverses the whole object graph in your memory, starting from those Garbage Collection Roots and following references from the roots to other objects, e.g. instance fields. Every object the GC visits is marked as alive.

When the marking phase finishes, every live object is marked. All other objects are thus unreachable from the GC roots, implying that your application cannot use the unreachable objects anymore. Such objects are considered garbage and GC should get rid of them.

reference:

https://www.amazon.com/depth-understanding-Java-Virtual-Machine/dp/7111641248

https://www.youtube.com/watch?v=Rnn8HW0XSbg

https://plumbr.io/handbook/garbage-collection-algorithms