2

I see a lot examples in code were we see the next thing:

HandlerThread thread = new HandlerThread("Thread1");
        thread.start();
        mLoadHandler = new Handler(thread.getLooper())


   mLoadHandler.post(new Runnable() {
            public void run() {
                // run some code
                //methodA();
            }
        });

you can find it also in:

https://github.com/android/platform_packages_apps_browser/blob/master/src/com/android/browser/OpenDownloadReceiver.java

https://github.com/CyanogenMod/android_packages_apps_Gallery3D/blob/8621799408a58f6b9da3492382ce929b3c93c7de/src/com/cooliris/picasa/PicasaService.java

Why they create a HandlerThread for only one purpose: to pass it's Looper to a new Handler. Why don't just extend the HandlerThread and do the all code (methodA()) there? OR create a Handler instance and call there to:

 Looper.prepare();
 Looper.loop();
RonTr
  • 137
  • 10
  • so post the code of custom `HandlerThread` class, also grep the official android code and see how google is using `HandlerThread` class – pskink Feb 20 '16 at 16:45
  • @RonTR I provided one scenario in an answer below that addresses the question you asked about why someone would choose to create a new HandlerThread and post Runnables to it instead of putting all the logic in a custom HandlerThread subclass. Was that clear to you about why someone would make this design decision? – Doug Stevenson Feb 21 '16 at 18:59
  • @DougStevenson ,Thank you for you answer, but I really don't see any difference, can you please share some code to see exactly the difference – RonTr Feb 26 '16 at 04:56

2 Answers2

0

With only the code you show, there is not much difference in dealing with HandlerThread either way.

However, if there are lots of different components all trying to post different Runnables to the same thread, you'd rather not cram all their logic into one class. It's easier in this case to pass around a Handler for these different components to share. This is one scenario, but there could be others.

Doug Stevenson
  • 297,357
  • 32
  • 422
  • 441
  • 1
    I think this should be in the comment section and not in the answer – Jaffer Wilson Feb 20 '16 at 05:50
  • It answers the question: Why they create a HandlerThread for only one purpose: to pass it's Looper to a new Handler. Why don't just extend the HandlerThread and do the all code (methodA()) there? – Doug Stevenson Feb 20 '16 at 06:07
  • I don't have a major problem with the question as asked. I provided one case where someone would create and share a new HandlerThread among Runnables instead of subclassing it and putting all the logic there. I can't provide them all, but it is a valid scenario as requested. – Doug Stevenson Feb 21 '16 at 18:49
0

If you want to get the Handler which is associated with the ThreadHandler class you create, you must pass the Looper associated with that ThreadHadler, otherwise the Handler will be associated to the current thread in which it was instantiated. The purpose of creating such a HandlerThread is generally when you want to do same type of job multiple times, you can simply use this Handler object to post a message to the new thread.

I think your question is why would you want to create an inner class rather than implement a separate independent class. If you are creating an inner class then you can access directly members of the the containing class. If you implement a separate class, you would need to pass the required variables/view values to the new class.

Sumit Trehan
  • 3,985
  • 3
  • 27
  • 42