How can a Thread return a value after finishing its job?

Question

Let's say we have this simple example:

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

}

How can the Thread after finishing its job return me the String temp?

Answer 1

You can achieve this by the Observer pattern. on finishing the thread notifies all listeners that it's finished and they can retrieve the value (through a getter). Or it can even already send the computed value.

Or you can use a task, see FutureTask, a runnable ( indeed as stated below a Callable ) that returns a result and can throw exceptions.

Answer 2

Look at Future interface javadoc. It has sample usage showing you how to do this.

Answer 3

Make use of the (relatively) new Callable<T> instead of Runnable.

Here is a (simple) example:

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

If you don't want to swap the solution to use Callable objects then you can use also queues and return the result from the threads that way. I re-wrote your example like this:

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

Note that you shall think of synchronization and concurrency!