[Android][Memory] Memory Optimization + GC Management Concepts Sharing

Today’s post
I plan to take notes
to record what I understand about Android memory management
I intend to keep updating this note
If I learn more about Android memory management
I want to consolidate it in this one post

Android Memory Note

heap:
The Android virtual machine continuously tracks memory allocation in the heap
The heap is a block of memory used to store system-allocated java/kotlin objects

garbage collection (gc):
Its goal in Android is to achieve the following:

• Find unused objects
• Reclaim the memory used by these objects and return it to the heap

In a multi-task environment
Android limits the size of each heap
This size is determined by the amount of available RAM on the Android device

Additionally
When the heap is full
If the system still tries to allocate memory
It may result in an OutOfMemoryError

Frequent Garbage Collection

Previously, I read an article that also referred to GC as memory churn
In other words
GC usually occurs when memory is needed in a short period
Due to insufficient heap space
It needs to allocate heap space for the app
While simultaneously freeing up heap space to compensate for the shortage
So frequent GC triggers can also cause memory-related issues

For example:
At the same time
The app needs to allocate a large amount of memory space for the objects you create
But due to insufficient heap space
GC is triggered to reclaim heap space

But in the back-and-forth iterations
The app gets stuck
Usually, it won’t show an OOM

But it causes lag or crashes
Leading to a poor user experience

Here’s an example with code:

This is a common implementation of a recycler view adapter
The bind() method is used to implement the logic for generating new items

val demoBitmap = BitmapFactory.decodeResource(itemView.context.resources, R.drawable.bg_demo_photo)

In this bind() method, there is a fixed image to be loaded into the item
If placed here
It means that each time bind() is called, the item will reload the bitmap image
In small projects or with a few images, you won’t notice much difference
But with a large number of repeated loads
Or when there are 100 or 1000 items
Each one reloading
It consumes a significant amount of heap space

Therefore, the simplest way is to load fixed items only once

Or you can use some third-party libraries to cache the images
Reducing the number of loads
Of course, using cache can also cause OOM
So you need to define or clear the cache under specific conditions
You can optimize based on the issues encountered in the project

Android Memory Leak

gc cannot clear object leaks with references
Because it thinks some places might still need this reference
This situation is commonly referred to as a memory leak

Inner Classes: When inner classes have references to outer classes, it can cause memory leaks
For example: Like the code above
Because the inner class accesses the outer showResult
And since AsyncTask runs in the background
The activity might have finished
But AsyncTask is still running
This can cause a memory leak

Solution to this problem
You can remove the method call to the external class
or use other methods to access the external class
such as using weak references

Using weak references can still access the external class
but it won’t be as strong as a strong reference, so it won’t persist in memory
When the garbage collector (GC) does not find a strong reference to the object, it will look for it and set it to null

Anonymous Classes: Some anonymous classes live longer than the external class
causing memory leaks

Static Variables: Using companion objects or static to modify certain classes
will cause the object to load initially
and then not be released
leading to memory leaks
for example, static activity