swirl logo

About     Archive     Feed     Impressum

Android: Datenaustausch zwischen Main-Thread und Worker-Threads

Hintergrund

Es gibt Situationen, in denen Operationen vom Main-Thread in separate Threads ausgelagert werden sollen. Hierzu bietet Android grundsätzlich verschiedene Lösungsansätze. In diesem Beitrag soll es um eine schlichte und leichtgewichtige Implementierung auf Basis von Handler und Looper gehen.

Implementierung

Zuerst geht es an die Implementierung des Worker-Threads: Hierzu erfolgt die Implementierung auf Basis eines einfachen Java-Threads:

class MyThread extends Thread {
    @Override
    public void run(){
    }
}

Im Main-Thread der Applikation erfolgt somit der Aufruf via

MyThread mThread = new MyThread();
mThread.start();

Um nun Nachrichten zwischen Threads auszutauschen, gilt es dem empfangenden Thread eine MessageQueue zu geben. Dies geschieht mithilfe der Klasse Looper. Die statische Methoden prepare() kümmert sich um die Erzeugung der Message-Queue. Mit Aufruf von loop() wird die Bearbeitung der Message-Queue gestartet:

class MyThread extends Thread {
    @Override
    public void run(){
           Looper.prepare();
           Looper.loop();
    }
}

Nachrichten senden und empfangen

Um Nachrichten empfangen und senden zu können wird eine Instanz vom Typ Handler benötigt. Wichtig an dieser Stelle ist, dass die erzeugte Handler-Instanz automatisch dem erzeugenden Thread zugeordnet wird. Mit Implementierung der Methode handleMessage(Message) lässt sich ein individuelles Handling eintreffender Nachrichten realisieren.

class MyThread extends Thread {
    public Handler mHandler;

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

           mHandler = new Handler() {
                   public void handleMessage(Message msg) {
                       // Nachricht verarbeiten
                   }
           };
           Looper.loop();
    }
}

Damit nun Nachrichten an diese Worker-Thread gesendet werden können, benötigt der Sender lediglich eine Referenz auf die Handler-Instanz des empfangenden Threads. Mit Aufruf von sendMessage(Message) lässt sich anschließend eine Nachricht an den zugehörigen Worker-Thread versenden:

Message msg = Message.obtain();
msg.obj = new HighComplexProcessingObject(someArgs);  // Eigentliche payload
mHandler.sendMessage(msg);
Hire me!