Question

I don’t want to create a vague question so I will try to make this as clear as possible (Going to try my best).

I know garbage collection has been a grey area in programming for a very long time. I am not certain with the case of android or other mobile phones.

What I know of garbage collection in android:

1. It collects class system class ojbects(Made by correction from an answer).
2. Edit* “GC collects activity items only once the activity is destroyed. Activity lifecycle is driven by its attributes in the manifest, also by the flags of the intent that that launched it.” – Seva Alekseyev . As commenter said.
3. You may force a garbage collection using “System.gc()” although this is not recommended as it may delete something important class item.

Now I obtained this information from stackoverflow(Now knowing that it is no longer a grey area for garbage collection)

Going to my question:

1. How do you get this information about the process or generic information(book, internet article, etc.) about garbage collection from?
2. If there is not answer for question 1 what are the other ways or methods that developers should be reminded when developing applications requiring the constant use of memory?

Answer 1

I’m not sure your information is correct.

It collects class system classes.

No. It collects instances of objects that are no longer reachable from any of the system roots. System roots include any static reference, any reference from a thread’s active stack frame, any active synchronization monitor, and anything held by a native piece of code (global or local). An object is considered live (and hence cannot be reclaimed) if there is a path from it to a root tracing the reference graph backwards. Any object that doesn’t not have a path to a root can be reclaimed by the garbage collector. Classes are referenced by a ClassLoader and are never reloaded and hence are not reclaimed by the system unless that ClassLoader is collected and all instances of those classes are collected. So Android never collects class system classes because that ClassLoader is never collected.

It collects items from activity “only” if android manifest file states that the activity is either hasNoHistory or singleTop

No. An activity is nothing more than an instance of an object. And when the reference to the activity is gone so goes all of the references it pointed to unless some other root points to that object. By setting singleTop=”true” you are only telling Android to instantiate a single instance of this activity, and all intents sent will be handle by that single instance. It doesn’t have any impact on GC. When an activity looses its path to a root it will be reclaimed regardless of what the settings on that activity were.

You may force a garbage collection using “System.gc()” although this is not recommended as it may delete something important class item.

No Garbage collection algorithms do not delete any live object. Under your definition above it implies GC can collect an object you were using which is incorrect. If it did that’s a big bug. That is also the beauty of Garbage Collection algorithms in that they are guaranteed to clean up garbage perfectly. If you are running out of memory the programmer has forgotten to remove a reference or you are being careless with your use of memory. The reason you aren’t suppose to call System.gc() is that you/your program has no clue when the best time is to reclaim memory. The garbage collector is trying to maximize the ratio of (the time your program runs) vs. (the time it spends collecting garbage). It keeps very detailed statistics and makes estimations about when its a good time to run garbage collection vs simply allocating more memory.

It’s like cleaning your house. You can’t clean at all times because it makes doing things take longer sometime you have to let it get dirty (Like cooking). However, if you never clean your house it can take all day to clean it. So there is a balance that you must strike between how dirty can it become before cleaning it up takes longer than performing the task.

This is why you shouldn’t calculate/guess/force GC in your program because Android has already implemented it for you, and will do a better job than you can ever hope to.

What does this mean for you the developer?

1. Let Android handle when GC should run.
2. Clean up references to help the GC know when something can be reclaimed. Be very careful about static references, and never allow a static to hold a reference to an activity, service, etc to one.
3. Don’t allocate lots of small amounts of short lived memory. This will force more GC time to clean up. By allocating memory conservatively you are by definition helping that ratio.

Most of the time GC is very hands off. The only problems developers get into is not establishing boundaries for long living objects vs. UI objects. If a long living objects has a reference back to the UI that’s a place you’ll have to unregister or else you’ll leak memory. It’s ok for the UI to hold references to long living objects, but not the other way around.

The real issue with Android is how much you make the garbage collector work. If you keep the amount of memory you are using small then the garbage collector doesn’t have big jobs it has to do. That doesn’t mean you should reuse objects or create object pools, etc. But, you should be aware of what statements are creating memory, and how long those objects live for.

There are volumes of information on Garbage collection in general and particularly Java’s Concurrent Mark and Sweep garbage collector. Android’s garbage collector is not as performant, but it’s pretty darn good. Most of the time I don’t worry about GC unless there is a problem so it’s mostly hands off.

And garbage collection isn’t a grey area. It’s very much well understood, and the industry has expanded the field quite a bit since Java was introduced in 1994.