Tell me how garbage collection works in managed programming languages.

Garbage Collection (GC) is an automatic memory management process that searches for and frees memory occupied by objects that are no longer used by the program.

Main principles of GC operation:

1. Determining object reachability: GC identifies which objects can be accessed from "garbage collection roots" (such as global variables, local variables of current threads). Objects reachable from these roots through reference chains are considered "alive".

2. Collecting unused objects: Objects that are not "alive" (i.e., no references from "roots" or other "alive" objects) are considered "garbage" and are eligible for freeing.

3. Freeing memory: GC frees the memory occupied by "garbage", making it available for creating new objects.

Types of GC algorithms:

• Reference Counting: Each object has a reference count. When the count reaches zero, the object is considered "garbage". Simple to implement but cannot handle cyclic references.
• Mark and Sweep:
  • Marking: Starting from "roots", GC traverses the object graph and marks all "alive" objects.
  • Sweeping: GC goes through the entire heap and frees space occupied by unmarked objects. This can lead to memory fragmentation.
• Mark and Compact: After marking "alive" objects, GC moves them to the beginning of the heap, freeing a contiguous block of memory. Reduces fragmentation.
• Copying: Divides the heap into two spaces. During garbage collection, "alive" objects are copied from one space to the other. Fast for short-lived objects but requires twice the memory.
• Generational GC: Divides the heap into several "generations". Based on the assumption that most objects are short-lived. Garbage collection is performed more frequently in "younger" generations where new objects are created.

In Android (JVM/ART), generational GC with various optimizations (such as concurrent collectors working in parallel with the main application thread) is most commonly used.

Features of JVM/ART GC:

• Runs on a separate thread or in parallel with the application.
• Can cause "pauses" in application operation during garbage collection (though modern algorithms minimize them).
• Does not guarantee immediate memory release after an object becomes unreachable.

Example of an unreachable object:

public class Example {
    public static void main(String[] args) {
        Object obj1 = new Object();
        Object obj2 = obj1; // obj2 references the same object as obj1
        obj1 = null; // Reference obj1 is removed
        // The object is still reachable through obj2

        obj2 = null; // Reference obj2 is removed
        // Now the object is unreachable and can be collected by GC
    }
}