Handler or Launching a Coroutine Job to do something in the MainThread

Question

I've been wondering about whether it is a better approach to use a Handler (Looper.getMainLooper()) or launch a new Coroutine Job to do small things on the Main Thread, like updating a View.

Handler:

val uiHandler = Handler(Looper.getMainLooper())

fun foo() {
    uiHandler.post { 
        someView.update()
    }
}

Coroutine

fun foo() {
    lifecycleScope.launch {
        someView.update()
    }
}

I really don't know and couldn't find anything related on the Internet, but I'd love to acquire that knowledge.

Equivalent

why are you not on the main thread ? what are you doing ? perhaps that's relevant to people giving answers – Gangue

Gotcha! There are some situations where you can find yourself having to do somethings in a background thread and in the Main Thread in the same method. Or where it is impossible to know in which thread you are in. – Equivalent

i understand what you're saying and when thread switching is needed, but i wanted to know what you are doing specifically :) are you doing background coroutine operations and then need to do something on the main thread when you're done, or why would you be on the background thread – Gangue

Actually my question is for common knowledge - having performance and memory as the main focus. We've gotta consider that foo() is not called from a coroutine. – Equivalent

Did you ever find the right solution? I am wondering the same. – Elwoodelwyn

Answer 1

You can do both, but I think the common practice is to use coroutines. I don't think handlers are lifecycle aware by default, but coroutines will get cancelled if the view or activity is destroyed. A lot of libraries use suspend functions, so you will have to use coroutines.

Based on this, coroutines add tasks to the event loop just like handlers. I was wondering how coroutines work internally and found this post that uses mainHandler.post { continuation.resume(value) } to dispatch a coroutine, so I doubt there will be major differences in performance.

Melisenda

Answer 2

well they both do the same thing. but if we want to choose we should consider these facts :

• in performing UI update on main thread, coroutine is recommended. because it has better consistency when coding with coroutines.

• if you want more control in timing stuff like delaying and posting at desired time, Handler is a better option.

• finally in today's android development, using coroutines and handling stuff with it is recommended.

Tholos