difference between Thread and Handler

Question

Can somebody tell me the deference between Thread and Handler? When we use Thread and when we use Handler?

I have two code in my project , But I can't understand them.

final Handler handler =  new Handler()
{
    @Override
    public void handleMessage(Message msg)
    {
        //  Do SomeThings
    } 
};

And

private class readThread extends Thread
{
    Handler mHandler;

    readThread(Handler h){
        mHandler = h;
        this.setPriority(Thread.MIN_PRIORITY);

    }

    @Override
    public void run()
    {
        //  Do SomeThings
    }
}

And in another method call the handler like this

read_thread = new readThread(handler);
            read_thread.start();

Which one run first?? Can somebody explain me?

you are not using mHandler field in readThread so what is it for? — pskink, Aug 01 '15 at 11:41
I don't know. I don't know anything about these codes. I'm trying to unedrestand them — Khodayar, Aug 01 '15 at 11:51

score 70 · Accepted Answer · edited May 30 '18 at 06:48

The same: you can both execute task asynchronously without blocking your current code,

The difference: Imagine you have a Runnable r = new Runnable{...}

When you use new Thread(r).start(), you actually created a new thread and run task asynchronously.
When you use new Handler().post(r) (or Message), you added the Runnable object to Looper and execute the code later in the same thread.

A Thread, generally MainThread or UIThread contains a Looper. When MainThread runs, it will loop the Looper and execute Runnable one by one.

When Thread is preferred:

When you're doing a heavy work like network communication, or decoding large bitmap files, a new thread is preferred. If a lot of thread is needed, maybe ExecutorService is preferred further. https://developer.android.com/reference/java/util/concurrent/ExecutorService.html

When Handler is preferred:

When you want to update UI objects (like TextView text) from other thread, it is necessary that UI objects could only be updated in UI Thread. Also, when you just want to run some light code later (like the delay for 300ms) you can use Handler because it's lighter and faster.

Please also refer to Handler vs AsyncTask vs Thread

score 7 · Answer 2 · answered Aug 01 '15 at 11:59

Thread actually creates new thread - part of job running in background relatively to current thread.

Handler itself doesn't provide any mechanisms for background job - it is just a tool to access message queue (Looper) associated with some thread. UI thread have Looper attached by default, so it is common practice to update UI with Handler.post(Runable) which means execute some piece of code on thread which is associated with this Handler.
As soon as Handler serves Looper, it can't be created in a thread which have no associated Looper.

score 5 · Answer 3 · answered Aug 01 '15 at 11:48

Threads are generic processing tasks that can do most things, but one thing they cannot do is update the UI.

Handlers on the other hand are background threads that allow you to communicate with the UI thread (update the UI).

So for example show a toast or a update a progress bar via a message (Runnable) posted to a handler but you can't if you start this runnable as a thread.

With handler you can also have things like MessageQueuing, scheduling and repeating.

I am yet to encounter a situation where I needed a thread in android.

I mostly use a combination of AsyncTasks and Handlers.

Handlers for the aforementioned tasks.

AsyncTasks for download/ data fetching and polling etc.

score 3 · Answer 4 · answered Nov 12 '19 at 10:41

Simply says,

Both are same concepts, but some key differences. Thread is a java(java.lang) concept and Handler is a android(android.os)OS concept.if you are using Handler instead of Thread , your OS will automatically manage the working of background processes. But if you are using Thread,it is not dependent on your android OS. So Threads can't manage memory efficiently as compared to Handler.

score 1 · Answer 5 · answered Jul 22 '20 at 10:05

Threads:

You can use the new Thread for long-running background tasks without impacting UI Thread. From java Thread. But here you can't update the UI from Thread.

Since normal Thread is not much useful for Android architecture, helper classes for threading have been introduced. You can find answers to your queries on the Threading performance documentation page.

Handler:

This class is responsible for enqueuing any task to the message queue and processing them. Each Handler can be associated with one single thread and that thread’s message queue.

There are two main uses for a Handler:

To schedule messages and runnables to be executed as some point in the future;
To enqueue an action to be performed on a different thread than your own.

Looper: Looper is a worker that keep a thread alive, It loops over message queue and send the message to respective Handler.

Message Queue: This class holds the list of messages to be dispatched by the looper. You can just call Looper.myqueue() to get list of messages. We do not normally deal with it.

difference between Thread and Handler

5 Answers5

Linked