Devolviendo valor de Thread

Tengo un método con HandlerThread. Se cambia un valor dentro de Thready me gustaría devolverlo al test()método. ¿Hay alguna forma de hacer esto?

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

Puede utilizar una matriz de variables final local. La variable debe ser de tipo no primitivo, por lo que puede usar una matriz. También necesita sincronizar los dos hilos, por ejemplo, usando un 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.
}

También puede usar un Executory un Callablecomo este:

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();
}

Por lo general, lo harías de esta manera

 public class Foo implements Runnable {
     private volatile int value;

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

     public int getValue() {
         return value;
     }
 }

Luego puede crear el hilo y recuperar el valor (dado que el valor se ha establecido)

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

tl;drun hilo no puede devolver un valor (al menos no sin un mecanismo de devolución de llamada). Debe hacer referencia a un hilo como una clase ordinaria y preguntar por el valor.

Lo que está buscando es probablemente la Callable<V>interfaz en lugar de Runnabley recuperar el valor con un Future<V>objeto, lo que también le permite esperar hasta que se haya calculado el valor. Puede lograr esto con un ExecutorService, que puede obtener de 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();
}

¿Qué tal esta solución?

No usa la clase Thread, pero ES concurrente y, de alguna manera, hace exactamente lo que solicita

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;}
});

Ahora todo lo que debe hacer es decir value.get()cada vez que necesite tomar su valor devuelto, el hilo se inicia en el mismo segundo en que da valueun valor para que nunca tenga que decirthreadName.start() .

Lo que Futurees, es una promesa al programa, usted le promete al programa que obtendrá el valor que necesita en algún momento en el futuro cercano

Si lo llama .get()antes de que termine, el hilo que lo llama simplemente esperará hasta que esté listo

Si desea obtener el valor del método de llamada, debe esperar a que finalice el hilo, lo que hace que el uso de hilos sea un poco inútil.

Para responder directamente a su pregunta, el valor se puede almacenar en cualquier objeto mutable al que tanto el método de llamada como el hilo tienen una referencia. Podrías usar el exteriorthis , pero eso no será particularmente útil más que para ejemplos triviales.

Una pequeña nota sobre el código en la pregunta: la extensión Threadsuele ser un estilo deficiente. De hecho, extender las clases innecesariamente es una mala idea. Noto que su runmétodo está sincronizado por alguna razón. Ahora, como el objeto en este caso es el Thread, puede interferir con lo que sea que Threaduse su bloqueo (en la implementación de referencia, algo que ver con joinIIRC).

Desde Java 8 en adelante tenemos CompletableFuture. En su caso, puede usar el método supplyAsync para obtener el resultado después de la ejecución.

Encuentre alguna ref. aquí https://www.baeldung.com/java-completablefuture#Processing

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

   completableFuture.get() //gives you the value

El uso de Future descrito en las respuestas anteriores hace el trabajo, pero un poco menos significativamente ya que f.get () bloquea el hilo hasta que obtiene el resultado, lo que viola la concurrencia.

La mejor solución es utilizar ListenableFuture de Guava. Un ejemplo :

    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)
        {

        }
    };

Con pequeñas modificaciones en su código, puede lograrlo de una manera más genérica.

 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();

Solucion:

1. Cree un Handlersubproceso en la interfaz de usuario, que se llama comoresponseHandler
2. Inicialice esto Handlerdesde LooperUI Thread.
3. En HandlerThread, publicar un mensaje en esteresponseHandler
4. handleMessgaemuestra un Toastvalor recibido del mensaje. Este objeto de mensaje es genérico y puede enviar diferentes tipos de atributos.

Con este enfoque, puede enviar varios valores al hilo de la interfaz de usuario en diferentes momentos. Puede ejecutar (publicar) muchos Runnableobjetos en esto HandlerThready cada uno Runnablepuede establecer un valor en el Messageobjeto, que puede ser recibido por UI Thread.