Wie erstelle ich einen Looper-Thread und sende ihm sofort eine Nachricht?

Ich habe einen Arbeitsthread im Hintergrund, der Nachrichten verarbeitet. Etwas wie das:

class Worker extends Thread {

    public volatile Handler handler; // actually private, of course

    public void run() {
        Looper.prepare();
        mHandler = new Handler() { // the Handler hooks up to the current Thread
            public boolean handleMessage(Message msg) {
                // ...
            }
        };
        Looper.loop();
    }
}

Vom Haupt-Thread (UI-Thread, nicht dass es darauf ankommt) möchte ich so etwas machen:

Worker worker = new Worker();
worker.start();
worker.handler.sendMessage(...);

Das Problem ist, dass ich mich auf eine schöne Rennbedingung vorbereite: Zum Zeitpunkt des worker.handlerLesens kann nicht sichergestellt werden, dass der Worker-Thread diesem Feld bereits zugewiesen wurde!

Ich kann das nicht einfach Handleraus dem WorkerKonstruktor des erstellen , da der Konstruktor auf dem Hauptthread ausgeführt wird, sodass sich der Konstruktor Handlerdem falschen Thread zuordnet.

Dies scheint kaum ein ungewöhnliches Szenario zu sein. Ich kann mir mehrere Problemumgehungen einfallen lassen, die alle hässlich sind:

1. Etwas wie das:

   class Worker extends Thread {
   
       public volatile Handler handler; // actually private, of course
   
       public void run() {
           Looper.prepare();
           mHandler = new Handler() { // the Handler hooks up to the current Thread
               public boolean handleMessage(Message msg) {
                   // ...
               }
           };
           notifyAll(); // <- ADDED
           Looper.loop();
       }
   }
   

   Und aus dem Hauptthema:

   Worker worker = new Worker();
   worker.start();
   worker.wait(); // <- ADDED
   worker.handler.sendMessage(...);
   

   Aber das ist auch nicht zuverlässig: Wenn das notifyAll()vor dem passiert wait(), werden wir nie geweckt!

2. Übergeben einer Initiale Messagean den WorkerKonstruktor des Konstruktors, damit die run()Methode sie veröffentlicht. Eine Ad-hoc-Lösung funktioniert nicht für mehrere Nachrichten oder wenn wir sie nicht sofort, sondern kurz danach senden möchten.

3. Beschäftigt warten, bis das handlerFeld nicht mehr ist null. Ja, ein letzter Ausweg ...

Ich möchte ein Handlerund MessageQueueim Namen des WorkerThreads erstellen , aber dies scheint nicht möglich zu sein. Was ist der eleganteste Ausweg?

Eventuelle Lösung (minus Fehlerprüfung) dank CommonsWare:

class Worker extends HandlerThread {

    // ...

    public synchronized void waitUntilReady() {
        d_handler = new Handler(getLooper(), d_messageHandler);
    }

}

Und aus dem Hauptthema:

Worker worker = new Worker();
worker.start();
worker.waitUntilReady(); // <- ADDED
worker.handler.sendMessage(...);

Dies funktioniert dank der Semantik, HandlerThread.getLooper()die blockiert, bis der Looper initialisiert wurde.

Im Übrigen ähnelt dies meiner obigen Lösung Nr. 1, da die HandlerThreadungefähr wie folgt implementiert ist (ich muss Open Source lieben):

public void run() {
    Looper.prepare();
    synchronized (this) {
        mLooper = Looper.myLooper();
        notifyAll();
    }
    Looper.loop();
}

public Looper getLooper() {
    synchronized (this) {
        while (mLooper == null) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
    }
    return mLooper;
}

Der Hauptunterschied besteht darin, dass nicht überprüft wird, ob der Arbeitsthread ausgeführt wird, sondern dass tatsächlich ein Looper erstellt wurde. und der Weg, dies zu tun, besteht darin, den Greifer in einem privaten Feld zu lagern. Nett!

Schauen Sie sich den Quellcode von an HandlerThread

@Override
     public void run() {
         mTid = Process.myTid();
         Looper.prepare();
         synchronized (this) {
             mLooper = Looper.myLooper();
             notifyAll();
         }
         Process.setThreadPriority(mPriority);
         onLooperPrepared();
         Looper.loop();
         mTid = -1;
     }

Wenn Sie Thread in Worker erweitern und Ihren eigenen Looper implementieren, sollte Ihre Haupt-Thread-Klasse Worker erweitern und Ihren Handler dort festlegen.

Das sind meine Lösungen: MainActivity:

//Other Code

 mCountDownLatch = new CountDownLatch(1);
        mainApp = this;
        WorkerThread workerThread = new WorkerThread(mCountDownLatch);
        workerThread.start();
        try {
            mCountDownLatch.await();
            Log.i("MsgToWorkerThread", "Worker Thread is up and running. We can send message to it now...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Toast.makeText(this, "Trial run...", Toast.LENGTH_LONG).show();
        Message msg = workerThread.workerThreadHandler.obtainMessage();
        workerThread.workerThreadHandler.sendMessage(msg);

Die WorkerThread-Klasse:

public class WorkerThread extends Thread{

    public Handler workerThreadHandler;
    CountDownLatch mLatch;

    public WorkerThread(CountDownLatch latch){

        mLatch = latch;
    }


    public void run() {
        Looper.prepare();
        workerThreadHandler = new Handler() {
            @Override
            public void handleMessage(Message msg) {

                Log.i("MsgToWorkerThread", "Message received from UI thread...");
                        MainActivity.getMainApp().runOnUiThread(new Runnable() {

                            @Override
                            public void run() {
                                Toast.makeText(MainActivity.getMainApp().getApplicationContext(), "Message received in worker thread from UI thread", Toast.LENGTH_LONG).show();
                                //Log.i("MsgToWorkerThread", "Message received from UI thread...");
                            }
                        });

            }

        };
        Log.i("MsgToWorkerThread", "Worker thread ready...");
        mLatch.countDown();
        Looper.loop();
    }
}

    class WorkerThread extends Thread {
            private Exchanger<Void> mStartExchanger = new Exchanger<Void>();
            private Handler mHandler;
            public Handler getHandler() {
                    return mHandler;
            }
            @Override
            public void run() {
                    Looper.prepare();
                    mHandler = new Handler();
                    try {
                            mStartExchanger.exchange(null);
                    } catch (InterruptedException e) {
                            e.printStackTrace();
                    }
                    Looper.loop();
            }

            @Override
            public synchronized void start() {
                    super.start();
                    try {
                            mStartExchanger.exchange(null);
                    } catch (InterruptedException e) {
                            e.printStackTrace();
                    }
            }
    }