Beispielkommunikation mit HandlerThread

Ich möchte einen HandlerThread aus dem GUI-Thread einrichten. Einige Zeit später, wenn auf der GUI auf eine Schaltfläche geklickt wird, wird callHello() ausgeführt, das dann eine Nachricht an ein HelloLogger-Objekt sendet, das sich auf dem Nicht-GUI-Thread befindet, der “Hello World” asynchron protokolliert. Ich habe eine Reihe von Dingen ausprobiert, einige blockieren auf unbestimmte Zeit, andere erhalten die Nachricht nie usw. usw. Der folgende Code ist mehr oder weniger so nah wie ich, könnte ihn bitte jemand ändern, damit er funktioniert?

public class HandlerThreadExample {

    private MyHandlerThread mMyHandlerThread;
    private Looper mLooper;
    private Handler mHandler;

    public HandlerThreadExample(){
        mMyHandlerThread = new MyHandlerThread();
        mMyHandlerThread.start();
        mLooper = mMyHandlerThread.getLooper();
    }
    public void callHello() {
        mHandler.sendEmptyMessage(1);
    }
    private class MyHandlerThread extends HandlerThread {
        private HelloLogger mHelloLogger;
        private Handler mHandler;
        public MyHandlerThread() {
            super("The MyHandlerThread thread", HandlerThread.NORM_PRIORITY);
        }
        public void run (){
            mHelloLogger = new HelloLogger();
            mHandler = new Handler(getLooper()){
                public void handleMessage(Message msg){
                    mHelloLogger.logHello();
                }
            };
            super.run();
        }
    }
    private class HelloLogger {
        public HelloLogger (){
        }
        public void logHello(){
            Log.d("HandlerThreadExample", "Hello World");
        }
    }
}

Beste gefundene Beispiele:

• HandlerThread-Test
• Wie erstelle ich einen Looper-Thread und sende ihm dann sofort eine Nachricht?
• Asynchrone Aufrufe mit Handler
• HandlerThread vs. Executor – Wann ist einer besser geeignet als der andere?
• Beste Verwendung von HandlerThread gegenüber anderen ähnlichen Klassen
• Android-HandlerThread
• HandlerThread-Beispiele
• Android: Übergeben von Daten zwischen Haupt- und Worker-Threads
• Java-synchronisiert
• Senden von Nachrichten zwischen Threads mithilfe der Aktivitäts-Thread-Warteschlange und der Handler-Klasse
• Einführung in Looper und Handler
• developer.android: Angeben des Codes, der in einem Thread ausgeführt werden soll

Wenigstens kann ich jetzt die verdammten Tabs schließen

Lösung mit freundlicher Genehmigung von pskink

public class HandlerThreadExample2 {
    private static int MSG_START_HELLO = 0;
    private static int MSG_HELLO_COMPLETE = 1;
    private HandlerThread ht;
    private Handler mHtHandler;
    private Handler mUiHandler;
    private boolean helloReady = false;
    public HandlerThreadExample2(){
        ht = new HandlerThread("The new thread");
        ht.start();
        Log.d(App.TAG, "UI: handler thread started");
        mUiHandler = new Handler(){
            public void handleMessage(Message msg){
                if (msg.what == MSG_HELLO_COMPLETE){
                    Log.d(App.TAG, "UI Thread: received notification of sleep completed ");
                    helloReady = true;              }
            }
        };
        mHtHandler = new Handler(ht.getLooper()){
            public void handleMessage (Message msg){
                if (msg.what == MSG_START_HELLO){
                    Log.d(App.TAG, "handleMessage " + msg.what + " in " + Thread.currentThread() + " now sleeping");
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Log.d(App.TAG, "Woke up, notifying UI thread...");
                    mUiHandler.sendEmptyMessage(MSG_HELLO_COMPLETE);
                }
            }
        };
    }
    public void sendLongHello(){
        if (helloReady){
            Log.d(App.TAG, "sending hello " + Thread.currentThread());      
            mHtHandler.sendEmptyMessage(MSG_START_HELLO);
            helloReady = false;
        } else {
            Log.e(App.TAG, "Cannot do hello yet - not ready");
        }
    }
}

Dies ist ein funktionierendes Beispiel:

HandlerThread ht = new HandlerThread("MySuperAwesomeHandlerThread");
ht.start();
Handler h = new Handler(ht.getLooper()) {
    public void handleMessage(Message msg) {
        Log.d(TAG, "handleMessage " + msg.what + " in " + Thread.currentThread());
    };
};
for (int i = 0; i < 5; i++) {
    Log.d(TAG, "sending " + i + " in " + Thread.currentThread());
    h.sendEmptyMessageDelayed(i, 3000 + i * 1000);
}

AKTUALISIEREN:

Erstellen Sie zwei Klassenfelder:

Handler mHtHandler;
Handler mUiHandler;

und versuch das:

HandlerThread ht = new HandlerThread("MySuperAwsomeHandlerThread");
ht.start();
Callback callback = new Callback() {
    @Override
    public boolean handleMessage(Message msg) {
        if (msg.what == 0) {
            Log.d(TAG, "got a meaasage in " + Thread.currentThread() + ", now sleeping... ");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Log.d(TAG, "woke up, notifying ui thread...");
            mUiHandler.sendEmptyMessage(1);
        } else
        if (msg.what == 1) {
            Log.d(TAG, "got a notification in " + Thread.currentThread());
        }
        return false;
    }
};
mHtHandler = new Handler(ht.getLooper(), callback);
mUiHandler = new Handler(callback);
mHtHandler.sendEmptyMessageDelayed(0, 3000);

Kannst du natürlich loswerden Callback Schnittstelle und erstellen Sie zwei Handler mit überschrieben handleMessage Methode…

Das Problem, das Sie sehen, liegt daran, dass Ihre äußere Klasse ein privates mHandler-Feld verwendet, ebenso wie Ihr HandlerThread. Das Feld der äußeren Klasse wird nicht initialisiert. Sie benötigen den inneren mHandler nicht. Die äußere Klasse kann einen Handler aus dem Looper erstellen, den Sie direkt nach dem Aufruf von start() abrufen.