如何从另一个线程调用线程的getHandler（）方法？

Question

I'm running into the problem where one thread attempts to send a message to another thread's handler before its handler has been initialized. This asynchronous thread communication can easily lead to a nullpointerexception.

I'm trying to use the following code to fix this (a wait-notify algorithm) but I don't understand how to call getHandler() from my thread sending messages because I keep getting the "Non-static method cannot be called from a static context" error.

The attempted fix to the message-receiveing thread's code:

public class LooperThread extends Thread {

    private static Handler mHandler;

    public void run() {
        Looper.prepare();

        synchronized (this) {
            mHandler = new Handler() {
                public void handleMessage(Message msg) {
                    // process incoming messages here
                }
            };
            notifyAll();
        }

        Looper.loop();
    }

    public synchronized Handler getHandler() {
        while (mHandler == null) {
            try {
                wait();
            } catch (InterruptedException e) {
                //Ignore and try again.
            }
        }
        return mHandler;
    }
}

When I try the following code I keep getting the "non-static method cannot be called from a static context compiler error.

message-sending thread:

public class SenderThread extends thread{
    private static Handler senderHandler;

    public void run(){
        Looper.prepare();

        senderHandler = LooperThread.getHandler(); //This is where the error occurs!

        //do stuff
        senderHandler.msg(obj);
        Looper.loop();
    }
}

I know that I probably shouldn't try to initialize the sender thread's handler from within the run() method since it will be called repeatedly and will therefore be wasteful. Where should I be calling LooperThread's getHandler() method from?

Background Info:

I used this question and one of the answers as a reference: How do I ensure another Thread's Handler is not null before calling it?

Answer 1

The meaning of the error Non-static method cannot be called from a static context is that you are trying to use a non-static (class member) in a static fashion (in your example, referring to LooperThread ). The fix is typically to make the method at fault static, eg public static synchronized Handler getHandler() .

In your case however you are using wait() which is a non-static method (and thus cannot be accessed from static context). Instead you should change mHandler to be non-static state (thus there will be an mHandler per thread - which is what you want): private Handler mHandler;

Inside of your SenderThread you will need to construct a LooperThread and then you can call its non-static getHandler() .

public class SenderThread extends Thread {
    private static Handler senderHandler;

    public void run(){
        Looper.prepare();

        LooperThread looperThread = new LooperThread();
        senderHandler = looperThread.getHandler(); // Should no longer error :-)

        //do stuff
        senderHandler.msg(obj);
        Looper.loop();
    }
}