Overview
Garbage collector is a process that clears up useless objects to free up memory for new allocations. GC is automatic memory management mechanisms. In low-level languages, memory management is the responsibility of the programmer.
GC structure
An Android application is a separate Linux process, which is forked from process called Zygote.
Zygote is a system process that preloads system libraries and frameworks to speed up app launches. It includes either ART or Dalvik
(depends on version of Android) virtual machines with embedded GC. GC works in isolation from application source-code and recent versions can run even concurrently.
GC benefits
Memory on mobile devices is limited, so proper memory management is important. Without removing unused objects and compacting memory, memory can run out of memory, leading to performance issues and and an OutOfMemoryError. GC helps prevent memory leaks and compacts the heap to reduce memory fragmentation.
GC also saves developers time by managing object references for them and leads to less errors due to automatic management.
Now that we understand the benefits of GC, let’s break down how it works and what mechanisms it uses. We will focus on the implementation of GC starting from Android Oreo, as it introduced significant optimizations, and recent versions have not changed much.
Garbage Collection Basics
Before diving into GC roots, we need to understand GC Roots. What are GC roots? GC roots are objects from which GC starts garbage collection.
There are several types of GC roots: Active Threads, Static Fields and other objects.
Basically GC divides the heap into three parts : Old and Young generations and Permanent Generation(or MetaSpace from JAVA 8)
We will not focus on Permanent Generation or MetaSpace, because it will not be garbage collected and commonly store metadata for source code.
So lets clarify Young Generation.
Young Generation
Young generation contains mostly short-lived objects. Young Generation contains 3 memory regions: Eden Space and two Survivor Spaces:
S0 and S1.
When an object is created, it is allocated in the Eden Space in Young Generation. Size of Eden Space takes most space in Young Generation because most of objects in program dies young. When Eden Space fills up, a Minor Garbage Collection (GC) cycle starts. It traces reachable objects starting from GC roots and removes unreachable ones. All reachable objects from Eden are moved to S0. Unreachable objects are removed.
In the next GC cycle, surviving objects from S0 move to S1, and vice versa. After several cycles, long-lived objects are promoted to the Old Generation. The whole algorithm is called Copying GC and it’s quite effective for short-lived objects since it doesn’t require compaction. Copying GC has a STOP-THE-WORLD phase, where the entire application pauses to perform Minor GC. However, it runs quickly, so noticeable lags are rare.Let’s see what happens with long-lived objects in Old Generation.
Old Generation
Old generation based on other algorithm called Mark-And-Sweep.
When the Old Generation fills up Major Garbage Collection cycle begins. Starting from GC root, Major GC marks objects reachable and unreachable using a single bit (1) - Object is Reachable, (1)- Object is unreachable. This phase called Mark. After marking objects, Sweep phase starts working. Unreachable objects are not immediately removed. Instead, GC frees their memory, and in some cases, Heap Compaction runs to reduce fragmentation. Heap Compaction is a process where GC moves small chunks of memory to free up space for larger allocations. It is similar to defragmentation, but for the Heap. Nowadays, the Mark-and-Sweep algorithm runs concurrently.
We talk about work of GC, so in this context we can talk about memory leaks now.
Memory leaks
A memory leak occurs when an object is no longer needed but remains referenced, preventing GC from reclaiming its memory.
The best way to track a memory leak is to use the Memory Profiler and collect Heap Dump.
Overall
Garbage Collector is a very efficient process that helps Android manage memory properly.
