How to run task in separate thread for the specific amount of time and return result?

Question

How to run the thread for the specific amount of time and return some result when time elapse?

The best solution I can think so far is to measure time manually. But maybe there is more elegant, out of the box solution? 

I have an algorithm that in each iteration improves previous solution. I'd like to run this code in a separate thread for the predefined amount of time. When the time elapse, the best (the latest) solution should be returned.

Since I want to return the solution, I can't just use Future#get(long timeout, TimeUnit unit) - it would result in TimeoutException. The same about interrupting thread after some time from the "controlling" thread - in such case, Future would be cancelled and returned null.

My current solution is as follows:

The timer logic:

private class ExecutionTimer {

    private final long executionTimeLimit;

    private long startTime;

    // accepts execution time limit in _miliseconds_
    public ExecutionTimer(final int executionTimeLimit) {
        this.executionTimeLimit = TimeUnit.MILLISECONDS.toNanos(executionTimeLimit);
    }

    public void start() {
        this.startTime = System.nanoTime();
    }

    public boolean hasElapsed() {
        return (System.nanoTime() - startTime) >= executionTimeLimit;
    }
}

...and the worker thread:

 private class WorkerThread implements Callable<Double> {

        private final ExecutionTimer executionTimer;

        public WorkerThread(final int executionTimeLimit) {
            this.executionTimer = new ExecutionTimer(executionTimeLimit);
        }

        @Override
        public Double call() throws Exception {
            executionTimer.start();

            double partialSolution = 0;
            while (!executionTimer.hasElapsed()) {
                // let's imagine that here solution is improved ;)
                partialSolution = new Random().nextDouble(); 
            }
            return partialSolution;
        }
    }

EDIT: The worker thread can work indefinitely without interrupting it from outside - it is fine because algorithm can always improve previous solution (of course after some significant amount of time improvements are relatively small)

Answer 1

You could store the intermediate results in a shared thread safe variable (for example volatile double in your case) - when your future times out, you can retrieve the latest calculated value from that variable.

In other words:

• if future.get(...) returns a value, use it
• if you get a TimeoutException, retrieve the value by calling yourWorkerThread.getLatestValue();, which returns a volatile double latestValue which is updated at every loop, instead of your local partialSolution.

Alternatively, this post points to the Guava library and other solution (that all come down to the 2 options discussed in my comment). Note that Guava, internally, uses a future with timeout.

Answer 2

I would suggest a Producer-Consumer pattern:

The algorithm that is responsible for the cultivation of the result is constantly producing new and better results and puts them into a shared thread safe resource.

The client who is interested in this result consumes this resource each predefined interval, set to the timeout in your question.

The resource itself could be a stream (e.g. BlockingQueue) or a single variable.

This has the advantages that it is very easy to reason about, it defines clear boundaries and is very flexible. For example: the client can block as long as there is no result at all, or it can block as long as there is no new and improved result. All variations on the producer consumer pattern, just tweak the producers notification condition.

Answer 3

Consider using Timer & TimerTask

import java.util.TimerTask;
import java.util.concurrent.Callable;
import java.util.concurrent.atomic.AtomicBoolean;

public class Solver implements Callable<Double> {

    private final AtomicBoolean running = new AtomicBoolean(true);

    public void stop() {
        this.running.set(true);
    }

    @Override
    public Double call() throws Exception {
        Double answer = null;
        while (this.running.get()) {
            answer = keepImproving();
        }
        // TODO Auto-generated method stub
        return answer;
    }

}

class Schedular extends TimerTask {

    private final Solver solver;

    public Schedular(Solver solver) {
        this.solver = solver;
    }

    @Override
    public void run() {
        this.solver.stop();
    }

}

Use something like below

final Solver solver = new Solver();
Schedular schedular = new Schedular(solver);
final Timer timer = new Timer();
timer.schedule(schedular, 0, TimeUnit.MINUTES.toMillis(1));

ExecutorService executor = // get a executor somehow
final Future<Double> future = executor.submit(solver);
final Double answer = future.get();
System.out.println(answer);

---

The idea is to use Timer & TimerTask to trigger the stop signal so that algorithm stop improving the answer.

Answer 4

You can use the normal Future.get(), it waits indefinately.