Handler's `handleMessage` returning thread id of main thread instead that of the worker thread

Question

I'm trying to get a hang of multi-threading in Android. My aim is to send data from the main thread to a worker thread.

I have a main activity with the following code in its onCreate-

protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        ThreadOne threadOne = new ThreadOne();
        threadOne.start();
        threadOneLooper = threadOne.getLooper();

        Message msg = new Message();
        msg.obj = "message.";

        Log.i("id--(threadOneLooper)", String.valueOf(threadOneLooper.getThread().getId()));
        Log.i("id--(Main)", String.valueOf(getMainLooper().getThread().getId()));

        TestHandler mHandler = new TestHandler(threadOneLooper);
        mHandler.handleMessage(msg);
    }

As you can observe, I store a reference of the worker thread's looper in threadOneLooper and then log the id of its associated thread. At the same time I also print the id of the main thread.

Following is the code for my thread -

public class ThreadOne extends Thread{

    @Override
    public void run() {

        if (Looper.myLooper() == null)
            Looper.prepare();

        Log.i("ThreadOne", "run()");

        // Just making sure all approaches give the same result
        Log.i("Id--Thread id 1", String.valueOf(getLooper().getThread().getId()));
        Log.i("Id--Thread id 2", String.valueOf(getId()));

        Looper.loop();
    }

     Looper getLooper() {
        if (Looper.myLooper() != null)
            return Looper.myLooper();
        else
            return null;
    }

And following is the code of my handler -

public class TestHandler extends Handler {

    TestHandler(Looper myLooper) {
        super(myLooper);
    }
    public void handleMessage(Message msg) {

        String txt = (String) msg.obj;
        Log.i("Handler", txt);
        Log.i("Id--(Handler)", String.valueOf(getLooper().getThread().getId()));
    }
}

Now, the problem is that I had assumed that the Log.i("Id--(Handler)", String.valueOf(getLooper().getThread().getId())); statement would log the thread id of ThreadOne since we are passing the thread's looper into the handler. However, the id being logged is of the main thread. Why is that? Is it correct to assume that handleMessage() is being executed on the main thread?

Please go through the Android Looper, Handler and MessageQueue. It will give you the answer https://blog.mindorks.com/android-core-looper-handler-and-handlerthread-bd54d69fe91a — noobEinstien, Apr 21 '19 at 10:12
The main reason is you created the handler inside main thread that why this handler always catch messages come to main thread — Jasurbek, Apr 21 '19 at 10:12
@Jasurbek But I'm passing the looper of the worker thread into the handler. Should not the handler associate itself with the worker in that case? — krtkush, Apr 21 '19 at 11:02
I don't have an answer yet. But I realised my approach was incorrect - https://stackoverflow.com/questions/37671500/calling-a-method-of-a-class-which-extends-thread-from-another-class Using your approach is giving me a null pointer exception. — krtkush, Apr 21 '19 at 13:56

score 1 · Accepted Answer · answered Apr 21 '19 at 14:27

The problem is with the getLooper() method of ThreadOne. The method returns myLooper() associated with the thread that called the method.

For returning a Looper associated with ThreadOne I'd suggest the following implementation of the class:

public class ThreadOne extends Thread {
    private Looper mLooper = null;

    @Override
    public void run() {
        Looper.prepare();
        mLooper = Looper.myLooper();

        Looper.loop();
    }

    Looper getLooper() {
        return mLooper;
    }
}

Note! The ThreadOne's Looper is null until it is running. You cannot get non-null reference to it earlier. You must check if the thread is running before calling the getLooper() method.

P.S. You might want to reconsider the approach with getting the ThreadOne's Looper. Having a Handler associated with ThreadOne might be enough (see the example of thread).

Handler's `handleMessage` returning thread id of main thread instead that of the worker thread

1 Answers1