Nevertheless we however sometimes bring crashes with OutOfMemory. Thus where’s the trash collector?
I’m likely to pay attention to the cases where huge things in memories can’t be removed for a lengthy period of time. This example is certainly not ultimately a memory leak — stuff are compiled at some point — so we often dismiss it. This isn’t better as it can certainly sometimes cause OOM errors.
Happening I’m describing is the Handler problem, and is normally recognized as a warning by Lint.
Basic Example
This really is a tremendously basic task. Observe that this unknown Runnable was published on the Handler with a very long delay. We’ll operate they and rotate the device few instances, then dispose of storage and determine they.
We now have seven strategies in memory now. This might be not great. Let’s see precisely why GC struggles to remove all of them.
The query I made to get a listing of all tasks continuing to be in memories is made in OQL (item Query code), in fact it is simple, but effective.
As you care able to see, among recreation are referenced by this$0 . This is exactly an indirect reference from unknown class toward holder course. This$0 is referenced by callback , that is after that referenced by a chain of after that ’s of content returning to the main thread.
If you generate a non-static class in the manager course, coffee brings an indirect reference to the master
After you post Runnable or content into Handler , it is after that stored in list of Message commands referenced from LooperThread before content Artist dating sites are accomplished. Posting delayed messages was a very clear leak for at least enough time of this delay benefits. Posting immediately causes a temporary problem besides in the event the queue of messages is large.
Static Runnable Answer
Let’s make an effort to tackle a memories drip by getting gone this$0 , by transforming the unknown lessons to fixed.
Operate, rotate and acquire the mind dump.
What, once again? Let’s read which keeps referring to recreation .
Have a look at the bottom of the tree — task is held as a reference to mContext inside mTextView your DoneRunnable course. Utilizing static inner sessions isn’t enough to conquer mind leakages, nonetheless. We must create a lot more.
Fixed Runnable With WeakReference
Let’s keep using iterative fixes to get gone the reference to TextView, which will keep activity from becoming destroyed.
Keep in mind that we are keeping WeakReference to TextView, and let’s work, turn and dispose of storage.
Be mindful with WeakReferences. They may be null any kind of time minute, thus deal with them first to an area variable (hard reference) immediately after which always check to null before utilize.
Hooray! Singular task instance. This solves our very own memories issue.
So because of this method we should:
- Use static interior tuition (or exterior sessions)
- Use WeakReference to stuff manipulated from Handler / Runnable
Any time you compare this code towards the preliminary code, you might find a big difference in readability and rule approval. The original signal is a lot shorter and far better, and you’ll note that fundamentally, text in textView are going to be changed to ‘Done’. No need to look at rule to understand that.
Creating that much boilerplate signal is extremely boring, especially if postDelayed is set to a short while, like 50ms. You can find best and clearer options.
Washing All Information onDestroy
Handler class has a fascinating function — removeCallbacksAndMessages – which could take null as discussion. It’ll eliminate all Runnables and communications posted to a specific handler. Let’s utilize it in onDestroy .
Let’s run, turn and dump storage.
Good! Only one instance.
This process are a lot better than the earlier one, because helps to keep laws obvious and understandable. The only real overhead should don’t forget to clean all communications on task / fragment demolish.
I have another option which, if you’re lazy like me, you might like much more. 🙂
Utilize WeakHandler
The Badoo staff developed the interesting concept of exposing WeakHandler – a class that acts as Handler , but is way less dangerous.
It requires benefit of tough and weakened records to eradicate memory space leakages. I shall explain the theory thoroughly a bit afterwards, but let’s check out the code initially:
Very similar to the initial rule besides one lightweight change — instead of utilizing android.os.Handler , I’ve put WeakHandler . Let’s run, turn and dump memory:
Nice, isn’t it? The laws try cleaner than ever, and memory try thoroughly clean at the same time! 🙂
To make use of they, merely put dependency to your build.gradle:
And import they inside coffee course:
Go to Badoo’s github webpage, where you can fork they, or learn it’s resource code https://github.com/badoo/android-weak-handler
WeakHandler. The way it operates
An important aim of WeakHandler is to keep Runnables / information hard-referenced while WeakHandler can be hard-referenced. As soon as it may be GC-ed, all emails is going away besides.
Here’s a straightforward diagram that demonstrates differences between making use of regular Handler and WeakHandler to create anonymous runnables:
Taking a look at the top diagram, task keeps a mention of Handler , which content Runnable (places they into queue of communications referenced from Thread). All things are okay except the indirect guide from Runnable to Activity . While information is within the queue, all graphs can’t become garbage-collected.
By comparison, for the base diagram Activity holds WeakHandler , which will keep Handler around. Whenever we query it to create Runnable , it really is wrapped into WeakRunnable and posted. And so the content waiting line helps to keep reference and then WeakRunnable . WeakRunnable helps to keep poor mention of the specified Runnable , therefore, the Runnable tends to be garbage-collected.
Another little secret is that WeakHandler however keeps a hard mention of the required Runnable , to avoid it from getting garbage-collected while WeakRunnable was productive.
The side-effect of employing WeakHandler usually all emails and runnables is almost certainly not executed if WeakHandler happens to be garbage-collected. Avoiding that, merely hold a reference to it from task. Once task is able to be obtained, all graphs with WeakHandler will collected besides.
Conclusions
Utilizing postDelayed in Android calls for additional work. To obtain it we created three various methods:
- Need a fixed inner Runnable / Handler with WeakReference to owner lessons
- Evident all communications from Handler in onDestroy of Activity / Fragment
- Utilize WeakHandler from Badoo as a sterling silver round
It’s your decision to decide on your chosen method. The second appears very reasonable, but demands a little extra perform. The next try my favourite, certainly, however it require some interest too — WeakHandler should not be used without difficult reference from external. And thanks for scanning!