¿Cómo puede un subproceso devolver un valor después de terminar su trabajo?

Question

Digamos que tenemos este sencillo ejemplo:

public Example extends Thread{ 

    String temp;  

    public Example(){ 
    } 

    @Override 
    public void run(){ 
     . 
     . 
     . 
     . 
     temp = "a_value"; 
    } 

    public static void main(String[] args) { 

     Example th = new Example(); 
     th.start(); 
    } 

} 

¿Cómo puede el hilo después de terminar su trabajo me devuelva la temperatura de cuerdas?

Answer 1

Puede lograr esto mediante el patrón Observer. al finalizar el hilo notifica a todos los oyentes que está terminado y que pueden recuperar el valor (a través de un getter). O incluso puede enviar el valor calculado.

O puede utilizar una tarea, consulte FutureTask, un ejecutable (de hecho, como se indica a continuación en una llamada) que devuelve un resultado y puede arrojar excepciones.

Answer 2

Mire Future interfaz javadoc. Tiene un uso de muestra que le muestra cómo hacer esto.

Answer 3

Hacer uso de la (relativamente) nueva Callable<T> en lugar de Ejecutable (disponible en 1.5 y versiones más recientes):

Aquí está una (simple) ejemplo:

import java.util.concurrent.Callable; 
import java.util.concurrent.ExecutionException; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.Future; 


public class Main { 

    public static void main(final String[] argv) { 
     final ExecutorService service; 
     final Future<String> task; 

     service = Executors.newFixedThreadPool(1);   
     task = service.submit(new Foo()); 

     try { 
      final String str; 

      // waits the 10 seconds for the Callable.call to finish. 
      str = task.get(); // this raises ExecutionException if thread dies 
      System.out.println(str); 
     } catch(final InterruptedException ex) { 
      ex.printStackTrace(); 
     } catch(final ExecutionException ex) { 
      ex.printStackTrace(); 
     } 

     service.shutdownNow(); 
    } 
} 

class Foo implements Callable<String> { 
    public String call() { 
     try { 
      // sleep for 10 seconds 
      Thread.sleep(10 * 1000); 
     } catch(final InterruptedException ex) { 
      ex.printStackTrace(); 
     } 

     return ("Hello, World!"); 
    } 
} 

Answer 4

Si usted no quiere para intercambiar la solución para utilizar objetos invocables, puede usar también colas y devolver el resultado de los hilos de esa manera.
que re-escribió su ejemplo como este:

import java.util.PriorityQueue; 
import java.util.Queue; 

public class GetResultFromThread { 
    public static void main(String[] args) throws Exception { 
     Queue<String> queue = new PriorityQueue<String>(); 
     int expectedResults = 2; 
     for (int i = 0; i < expectedResults; i++) { 
      new Example(queue).start(); 
     } 

     int receivedResults = 0; 
     while (receivedResults < expectedResults) { 
      if (!queue.isEmpty()) { 
       System.out.println(queue.poll()); 
       receivedResults++; 
      } 
      Thread.sleep(1000); 
     } 
    } 
} 

class Example extends Thread { 
    private final Queue<String> results; 

    public Example(Queue<String> results) { 
     this.results = results; 
    } 

    @Override 
    public void run() { 
     results.add("result from thread"); 
    } 
} 

Tenga en cuenta que deberá pensar en la sincronización y la simultaneidad!