如何在Java中从主线程调用线程的方法

Question

I start a thread runnable within my Android code and it performs a task continually in a TimerTask until stopTimerTask() is called. I'd like to call the stopTimerTask() method in the thread from the main (UI) thread. I start the thread like so.

 public void test() {
        new Thread(runWaitResponseProcedure).start();
    }

    Runnable runWaitResponseProcedure = new Runnable() {
        startTimer();
    }

Please note that I definitely need to call this method from the UIThread.

Answer 1

If your UI thread has a reference to a Thread or Runnable object, then it can invoke any method of that object just as it does a method of any other object. The method will run in the invoking thread.

On the other hand, if you want a method to run in some specific thread then you must arrange for that thread to invoke it. You might do that, for instance, by raising a flag on the Runnable object in use by the target thread (which flag you must make available by defining it on a Runnable implementation class), and having instances of that class periodically test that flag to determine whether to invoke the method in question. Be sure to properly synchronize all accesses from such a flag.

On a side note, I observe that the anonymous Runnable implementation class in your sample code does not do anything like what you describe. It simply runs the startTimer() method of the outer class, once, then finishes.

Answer 2

I have used handlers/messengers to send messages from a thread that would invoke methods in my GUI. I'm sure you could reverse what I did and invoke methods in your runnable.

In the thread class you would define the following:

public class UpdaterHandler extends Handler{
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what){
            case 1:
                Bundle data = msg.getData();
                String update = data.getString("COMMAND");
                if(update.equals("STOP"){
                    stopTimer();
                break;

            default:
                super.handleMessage(msg);
                break;
        }

    }
}

Notes: msg.what contains an integer that you get to set like a tag in the main GUI. There could possibly be other messages flying through but the int 1 indicates its a message you sent. data.getString("COMMAND") --> The string command is the key that you gave for you data. You can make it whatever you want.

You'll need the following instance variables in your thread:

private UpdaterHandler handler = new UpdaterHandler();
private Messenger messenger = new Messenger(handler);

Now the messenger object you just made needs to get passed back to the UI. So in the constructor of your thread should probably be something like:

MyThreadClass(Context context){
((YourActivityClass)context).setMessenger(messenger)
....
}

This will give you the messenger in your UI

Now in your UI:

Message message;

stopTimerButton.setOnclickListener ..... {
      message = Message.obtain();
      bundle = new Bundle();
      bundle.putString("COMMAND", "STOP");
      message.setData(bundle);
      message.what = 1;
      messenger.send(message);
}

Note the messenger here is the one that gets set with setMessenger(...) that you called from the thread.

Now when you push the stop button in the UI it creates a new message object, stuff it with a command, then gives it to the messenger which you sent to the UI from the thread. Messenger.send() will automatically send this back to the running thread. In the thread the message gets deconstructed and based on its contents you can do whatever you want. In this case you call a stopTimer method within the thread itself.

In my own program I did this in the other direction it will be interesting to see if it works. Obviously you can copy and paste some of this code but I didn't fill in everything

-- You could also just interrupt the thread which will just stop it but I don't think that's what you want.

Answer 3

change your design pattern,problem can be solved,such as:

 public class RunTimerManager implements Runnable {

public void startTimer() {

}

public void stopTimer() {

}

public void test() {

    new Thread(this).start();

    try {
        wait(10000);
    } catch (Exception e) {
        e.printStackTrace();
    }
    stopTimer();

}

@Override
public void run() {
    // ........
}

}