Rückgabewert vom Thread

Ich habe eine Methode mit a HandlerThread. Ein Wert wird innerhalb von geändert Threadund ich möchte ihn an die test()Methode zurückgeben. Gibt es eine Möglichkeit, dies zu tun?

public void test()
{   
    Thread uiThread = new HandlerThread("UIHandler"){
        public synchronized void run(){
            int value; 
            value = 2; //To be returned to test()
        }
    };
    uiThread.start();
}

Sie können ein lokales endgültiges Variablenarray verwenden. Die Variable muss nicht primitiv sein, damit Sie ein Array verwenden können. Sie müssen auch die beiden Threads synchronisieren, z. B. mithilfe eines CountDownLatch :

public void test()
{   
    final CountDownLatch latch = new CountDownLatch(1);
    final int[] value = new int[1];
    Thread uiThread = new HandlerThread("UIHandler"){
        @Override
        public void run(){
            value[0] = 2;
            latch.countDown(); // Release await() in the test thread.
        }
    };
    uiThread.start();
    latch.await(); // Wait for countDown() in the UI thread. Or could uiThread.join();
    // value[0] holds 2 at this point.
}

Sie können auch ein Executorund ein Callablesolches verwenden:

public void test() throws InterruptedException, ExecutionException
{   
    ExecutorService executor = Executors.newSingleThreadExecutor();
    Callable<Integer> callable = new Callable<Integer>() {
        @Override
        public Integer call() {
            return 2;
        }
    };
    Future<Integer> future = executor.submit(callable);
    // future.get() returns 2 or raises an exception if the thread dies, so safer
    executor.shutdown();
}

Normalerweise würden Sie es so etwas tun

 public class Foo implements Runnable {
     private volatile int value;

     @Override
     public void run() {
        value = 2;
     }

     public int getValue() {
         return value;
     }
 }

Dann können Sie den Thread erstellen und den Wert abrufen (vorausgesetzt, der Wert wurde festgelegt).

Foo foo = new Foo();
Thread thread = new Thread(foo);
thread.start();
thread.join();
int value = foo.getValue();

tl;drEin Thread kann keinen Wert zurückgeben (zumindest nicht ohne Rückrufmechanismus). Sie sollten einen Thread wie eine normale Klasse referenzieren und nach dem Wert fragen.

Was Sie suchen, ist wahrscheinlich die Callable<V>Schnittstelle anstelle von Runnableund das Abrufen des Werts mit einem Future<V>Objekt, wodurch Sie auch warten können, bis der Wert berechnet wurde. Sie können dies mit einem erreichen ExecutorService, von dem Sie erhalten können Executors.newSingleThreadExecutor().

public void test() {
    int x;
    ExecutorService es = Executors.newSingleThreadExecutor();
    Future<Integer> result = es.submit(new Callable<Integer>() {
        public Integer call() throws Exception {
            // the other thread
            return 2;
        }
    });
    try {
        x = result.get();
    } catch (Exception e) {
        // failed
    }
    es.shutdown();
}

Wie wäre es mit dieser Lösung?

Es verwendet nicht die Thread-Klasse, aber es ist gleichzeitig und in gewisser Weise genau das, was Sie anfordern

ExecutorService pool = Executors.newFixedThreadPool(2); // creates a pool of threads for the Future to draw from

Future<Integer> value = pool.submit(new Callable<Integer>() {
    @Override
    public Integer call() {return 2;}
});

Jetzt müssen Sie nur noch sagen, value.get()wann immer Sie Ihren zurückgegebenen Wert abrufen müssen. Der Thread wird in der Sekunde gestartet, in der Sie valueeinen Wert angeben, damit Sie nie etwas dazu sagen müssen threadName.start().

Was Futureist, ist ein Versprechen an das Programm, Sie versprechen dem Programm, dass Sie ihm den Wert geben, den es irgendwann in naher Zukunft benötigt

Wenn Sie es aufrufen .get(), bevor es fertig ist, wartet der Thread, der es aufruft, einfach, bis es fertig ist

Wenn Sie den Wert von der aufrufenden Methode erhalten möchten, sollte er warten, bis der Thread beendet ist, was die Verwendung von Threads etwas sinnlos macht.

Um Ihre Frage direkt zu beantworten, kann der Wert in jedem veränderlichen Objekt gespeichert werden, auf das sowohl die aufrufende Methode als auch der Thread verweisen. Sie könnten das Äußere verwenden this, aber das wird nur für triviale Beispiele besonders nützlich sein.

Ein kleiner Hinweis zum Code in der Frage: Das Erweitern Threadist normalerweise ein schlechter Stil. In der Tat ist es unnötig, Klassen unnötig zu erweitern. Ich stelle fest, dass Ihre runMethode aus irgendeinem Grund synchronisiert ist. Da es sich in diesem Fall um das Objekt handelt Thread, können Sie in das eingreifen , wofür Threaddie Sperre verwendet wird (in der Referenzimplementierung etwas mit joinIIRC zu tun ).

Ab Java 8 haben wir CompletableFuture. In Ihrem Fall können Sie die Methode supplyAsync verwenden , um das Ergebnis nach der Ausführung abzurufen .

Bitte finden Sie einige ref. hier https://www.baeldung.com/java-completablefuture#Processing

    CompletableFuture<Integer> completableFuture
      = CompletableFuture.supplyAsync(() -> yourMethod());

   completableFuture.get() //gives you the value

Die Verwendung von Future, wie in den obigen Antworten beschrieben, erledigt den Job, blockiert den Thread jedoch etwas weniger als f.get (), bis er das Ergebnis erhält, das die Parallelität verletzt.

Die beste Lösung ist die Verwendung von ListenableFuture von Guava. Ein Beispiel :

    ListenableFuture<Void> future = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(1, new NamedThreadFactory).submit(new Callable<Void>()
    {
        @Override
        public Void call() throws Exception
        {
            someBackgroundTask();
        }
    });
    Futures.addCallback(future, new FutureCallback<Long>()
    {
        @Override
        public void onSuccess(Long result)
        {
            doSomething();
        }

        @Override
        public void onFailure(Throwable t)
        {

        }
    };

Mit kleinen Änderungen an Ihrem Code können Sie dies allgemeiner erreichen.

 final Handler responseHandler = new Handler(Looper.getMainLooper()){
            @Override
            public void handleMessage(Message msg) {
                //txtView.setText((String) msg.obj);
                Toast.makeText(MainActivity.this,
                        "Result from UIHandlerThread:"+(int)msg.obj,
                        Toast.LENGTH_LONG)
                        .show();
            }
        };

        HandlerThread handlerThread = new HandlerThread("UIHandlerThread"){
            public void run(){
                Integer a = 2;
                Message msg = new Message();
                msg.obj = a;
                responseHandler.sendMessage(msg);
                System.out.println(a);
            }
        };
        handlerThread.start();

Lösung:

1. Erstellen Sie einen HandlerIn-UI-Thread, der als bezeichnet wirdresponseHandler
2. Initialisieren Sie diese Handleraus Looperdem UI - Thread.
3. In HandlerThread, Post Nachricht auf diesemresponseHandler
4. handleMessgaezeigt einen Toastmit dem von der Nachricht empfangenen Wert. Dieses Nachrichtenobjekt ist generisch und Sie können verschiedene Arten von Attributen senden.

Mit diesem Ansatz können Sie mehrere Werte zu unterschiedlichen Zeitpunkten an den UI-Thread senden. Sie können viele RunnableObjekte auf diesem Objekt ausführen (veröffentlichen) HandlerThreadund jedes Runnablekann einen Wert im MessageObjekt festlegen , der vom UI-Thread empfangen werden kann.