CODEWITHSUNDEEP
androidmultithreadingserviceandroid-activityhandler
Tushar
Tushar

Reputation: 1122

Threads And Handlers

My question Is that What is the difference between Thread and Handler

Q1) What are their effects When they are used in 1) Activity 2) Service

Q2) What is difference between them in context with their life span I am using following codes for them.

1) ---------------------------

final Handler handler = new Handler();
Runnable runnable = new Runnable() 
{
    public void run() 
    {
        // do somthing
        handler.postDelayed(this, 1000);
    }
};
runnable.run();

2) ---------------------------

handler = new Handler()
{
    @Override
    public void handleMessage(Message msg) 
    {
        super.handleMessage(msg);
    }
};



new Thread(new Runnable()
{
    public void run() 
    {
        while(true)
        {
            try 
            {
                Thread.sleep(1000);
                handler.sendEmptyMessage(0);
            } catch (InterruptedException e) {} 
        }
    }
}).start();

Upvotes: 1

Views: 235

Answers (3)

Philip Couling
Philip Couling

Reputation: 14941

Q0) What is the difference between a thread and a handler?

A Thread is the same as it always is in programming. Each thread executes a single call to a method and then terminates. Each thread runs in parallel with every other thread. Threads are in short the way you have more than one thing happening at once.

Passing information between threads is notoriously difficult...

A Handler is Android's way of passing a message from one thread to another. Specifically it allows you to pass a set of instructions as a Runnable into a thread for that thread to execute. Typically they are used as a way for a thread to report its result back to the main thread when it's complete.

Q1) What are their effects When they are used in 1) Activity 2) Service

There is no difference between the way these two items behave in a service or an activity in general except that a service can exist in its own process if android is instructed to do so. Threads in different processes can not directly talk to one another. Services are there to share data,functionality and in some cases threads between activities. There is no requirement for them to have their own thread.

The one major point to note is that only the main thread can update the UI (activity).

Also networking specifically can not be done on the main thread. Networking is usually done from within a service so that the results can be shared but this is not necessary.

The limitations around what must and must not be done in the main thread make threading a little tricky, but these limitations are there to help you avoid freezing the UI unexpectedly.

Q2) What is difference between them in context with their life span I am using following codes for them.

Difficult to answer as I don't understand the purpose of your code.

As an example. Android no longer allows you to do any networking on the main thread as this could freeze the UI while it's waiting for the server to respond over a poor wifi connection. To change something on the UI based on something retrieved from the network you must use a thread to do the networking and pass the data back to the main thread to update the UI.

A (doctored) snippet from my code looks like this:

private final Handler handler = new Handler();

@Override
protected void onCreate( Bundle savedInstanceState ) {
    // irreverent to the example
    super.onCreate(savedInstanceState);
    super.setContentView(R.layout.abstract_main_view);

    // Here's the example
    Thread networkThread = new Thread() {

        @Override
        public void run() {
            // This could take several seconds
            final Collection<Player> players = service.lookupAllPlayers();
            Runnable uiUpdate = new Runnable() {

                @Override
                public void run() {
                    // This is quick, just adding some text on the screen
                    showPlayers(players);
                }
            };
            handler.post(uiUpdate);
        }
    };
    networkThread.start();
}

In this example:

  1. The handler is created and exists for the duration of this activity. Because this class is constructed by the main thread, the Handler is also. This means that all messages posted to this handler will be executed by main.

  2. networkThread is created and started by the main thread in onCreate. This lives until it has retrieved the data from the network and posted a response back to the main thread. Then it's done.

  3. The Runnable uiUpdate is created by networkThread once all data is retrieved. It does not have a thread associated and so does not execute right away. Instead it is posted back to main using the handler. It is then executed on the main thread and discarded once complete.

Upvotes: 0

Sharad Mhaske
Sharad Mhaske

Reputation: 1103

Handler: handler is used to do looper thing.that is to perform same task number of time. handler can be executed on main thread.

about Handler if its used in service it may get stop if phone state change to sleep. u can update the UI through handler if it used in activity.

Thread: Thread is used to things on separate than the main thread of an activity.

thread always runs in background even if phone state changes to sleep mode. u cant update the UI of as its not running on main thread.it can be done using asynctask not using simple java thread.

Upvotes: 1

Alexander
Alexander

Reputation: 48272

One can use a Handler to inform one thread of events from another thread.

Typical usage would be to inform the UI Thread from other threads.

We can not modify UI elements from other threads directly. So we can define a Handler as a member of an Activity instead. Activities are created on the UI Thread so this handler also is on UI Thread. So then from another thread we send a message to the Handler. And on receiving the message the Handler modifies some UI elements.

Upvotes: 0

Related Questions