However we nevertheless sometimes become collisions with OutOfMemory. Very where’s the garbage enthusiast?
I’m planning to focus on among the many instances when large stuff in storage can’t end up being cleaned for an extended period of time. This example isn’t finally a memory problem — stuff is going to be collected eventually — so we sometimes push it aside. That isn’t recommended because it can occasionally cause OOM mistakes.
The actual situation I’m explaining will be the Handler drip, which is normally found as a caution by Lint.
Practical Example
This will be a rather fundamental task. Observe that this anonymous Runnable has been posted to the Handler with a long delay. We’ll operate it and turn the device number of instances, after that dump mind and assess they.
We’ve seven tasks in memory space today. This might be not at all close. Let’s determine exactly why GC struggles to clear all of them.
The query I meant to have a summary of all tasks continuing to be in mind was developed in OQL (Object Query vocabulary), that’s very easy, but effective.
As you can see, among tasks try referenced by this$0 free BDSM online dating . That is an indirect resource from the anonymous lessons to the holder class. This$0 try referenced by callback , and that’s next referenced by a chain of further ’s of Message back into the main thread.
When you produce a non-static lessons in the manager lessons, Java creates an indirect reference to the particular owner
Once you post Runnable or information into Handler , it is then stored in directory of Message commands referenced from LooperThread before the message is accomplished. Publishing postponed emails is actually a clear drip for at least enough time associated with the wait importance. Posting straight away could cause a temporary drip too in the event the queue of information are large.
Fixed Runnable Solution
Let’s make an effort to over come a mind drip through getting rid of this$0 , by changing the unknown course to fixed.
Run, turn to get the memory space dump.
What, once again? Let’s read exactly who helps to keep referring to tasks .
Take a good look at the base of the forest — activity was held as a reference to mContext inside mTextView of one’s DoneRunnable course. Using static interior courses is certainly not enough to manage memories leakage, however. We have to would extra.
Static Runnable With WeakReference
Let’s continue using iterative repairs to get reduce the reference to TextView, which will keep activity from are ruined.
Observe that we’re maintaining WeakReference to TextView, and let’s operated, turn and dump memories.
Be cautious with WeakReferences. They may be null any kind of time moment, therefore fix them initially to a nearby adjustable (difficult guide) and inspect to null before incorporate.
Hooray! Only 1 activity incidences. This eliminates all of our mind complications.
Thus for this method we ought to:
- Need fixed inner classes (or outer classes)
- Incorporate WeakReference to all or any things manipulated from Handler / Runnable
Any time you evaluate this rule to your first signal, you might find an impact in readability and laws clearance. The initial code is significantly smaller and much clearer, and you’ll notice that fundamentally, text in textView are going to be changed to ‘Done’. You don’t need to look at code to understand that.
Writing anywhere near this much boilerplate rule is really tiresome, especially if postDelayed is set to a short while, instance 50ms. You will find much better and clearer possibilities.
Cleanup All Messages onDestroy
Handler lessons possess an interesting feature — removeCallbacksAndMessages – which can recognize null as argument. It’s going to pull all Runnables and information posted to some handler. Let’s use it in onDestroy .
Let’s run, turn and dump mind.
Great! Just one instance.
This method try way better compared to the previous one, as it keeps code clear and clear. The only overhead should make sure to remove all information on task / fragment kill.
I have yet another solution which, if you’re lazy anything like me, you could including a lot more. 🙂
Use WeakHandler
The Badoo personnel developed the fascinating idea of adding WeakHandler – a class that acts as Handler , it is way safer.
It can take advantage of hard and poor references to get rid of memory leakages. I shall describe the theory in more detail quite later on, but let’s look at the rule initial:
Very similar to the initial rule besides one small variation — in the place of making use of android.os.Handler , I’ve used WeakHandler . Let’s run, rotate and dispose of memory:
Nice, isn’t it? The laws try cleaner than ever before, and mind is clean aswell! 🙂
To use it, just put dependency your build.gradle:
And import it within java lessons:
Visit Badoo’s github webpage, where you could fork they, or study it is origin laws https://github.com/badoo/android-weak-handler
WeakHandler. The way it operates
The main goal of WeakHandler is hold Runnables / information hard-referenced while WeakHandler is also hard-referenced. As soon as it can be GC-ed, all communications should go away besides.
Is a straightforward diagram that demonstrates differences between making use of regular Handler and WeakHandler to create unknown runnables:
Studying the leading drawing, task keeps a mention of Handler , which content Runnable (puts it into waiting line of Messages referenced from Thread). Everything is great except the secondary reference from Runnable to task . While information is in the waiting line, all graphs can’t feel garbage-collected.
In contrast, from inside the base diagram Activity retains WeakHandler , which keeps Handler internally. As soon as we inquire it to post Runnable , it is wrapped into WeakRunnable and uploaded. Therefore, the information waiting line keeps reference only to WeakRunnable . WeakRunnable keeps weak reference to the desired Runnable , therefore the Runnable is garbage-collected.
Another small key usually WeakHandler nevertheless keeps a hard regard to the desired Runnable , to prevent it from becoming garbage-collected while WeakRunnable are energetic.
The side-effect of utilizing WeakHandler is the fact that all communications and runnables may not be accomplished if WeakHandler has been garbage-collected. To prevent that, simply hold a reference to it from task. When task is able to feel compiled, all graphs with WeakHandler will compiled nicely.
Conclusions
Making use of postDelayed in Android os calls for added work. To quickly attain they we came up with three different ways:
- Use a fixed internal Runnable / Handler with WeakReference to owner course
- Evident all messages from Handler in onDestroy of task / Fragment
- Need WeakHandler from Badoo as a gold bullet
It’s up to you to select your preferred technique. Another looks very affordable, but requires a little extra efforts. The 3rd try my preferred, demonstrably, nonetheless it call for some interest as well — WeakHandler shouldn’t be used without tough resource from exterior. And thank you so much for browsing!