Apply timeout control around Java operation

Question

I\'m using a third party Java library to interact with a REST API. The REST API can sometimes take a long time to respond, eventually resulting in a java.net.ConnectExcept

Answer 1

Here's a utility class I wrote, which should do the trick unless I've missed something. Unfortunately it can only return generic Objects and throw generic Exceptions. Others may have better ideas on how to achieve this.

public abstract class TimeoutOperation {

long timeOut = -1;
String name = "Timeout Operation"; 

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public long getTimeOut() {
    return timeOut;
}

public void setTimeOut(long timeOut) {
    this.timeOut = timeOut;
}

public TimeoutOperation (String name, long timeout) {
    this.timeOut = timeout;
}

private Throwable throwable;
private Object result;
private long startTime;

public Object run () throws TimeoutException, Exception {
    Thread operationThread = new Thread (getName()) {
        public void run () {
            try {
                result = doOperation();
            } catch (Exception ex) {
                throwable = ex;
            } catch (Throwable uncaught) {
                throwable = uncaught;
            }
            synchronized (TimeoutOperation.this) {
                TimeoutOperation.this.notifyAll();
            }   
        }
        public synchronized void start() {
            super.start();
        }
    };
    operationThread.start();
    startTime = System.currentTimeMillis();
    synchronized (this) {
        while (operationThread.isAlive() && (getTimeOut() == -1 || System.currentTimeMillis() < startTime + getTimeOut())) {
            try {
                wait (1000L);
            } catch (InterruptedException ex) {}
        }   
    }   
    if (throwable != null) {
        if (throwable instanceof Exception) {
            throw (Exception) throwable;
        } else if (throwable instanceof Error) {
            throw (Error) throwable;
        }   
    }   
    if (result != null) {
        return result;
    }   
    if (System.currentTimeMillis() > startTime + getTimeOut()) {
        throw new TimeoutException("Operation '"+getName()+"' timed out after "+getTimeOut()+" ms");
    } else {
        throw new Exception ("No result, no exception, and no timeout!");
    }
}

public abstract Object doOperation () throws Exception;

public static void main (String [] args) throws Throwable {
    Object o = new TimeoutOperation("Test timeout", 4900) {
        public Object doOperation() throws Exception {
            try {
                Thread.sleep (5000L);
            } catch (InterruptedException ex) {}
            return "OK";
        }
    }.run();
    System.out.println(o);
}   

}

Answer 2

Now we have our nice CompletableFuture , here an application to achieve what was asked.

CompletableFuture.supplyAsync(this::foo).get(15, TimeUnit.SECONDS)

Answer 3

This is probably the current way how this should be done with plain Java:

public String getResult(final RESTService restService, String url) throws TimeoutException {
    // should be a field, not a local variable
    ExecutorService threadPool = Executors.newCachedThreadPool();

    // Java 8:
    Callable<String> callable = () -> restService.getResult(url);

    // Java 7:
    // Callable<String> callable = new Callable<String>() {
    //     @Override
    //     public String call() throws Exception {
    //         return restService.getResult(url);
    //     }
    // };

    Future<String> future = threadPool.submit(callable);
    try {
        // throws a TimeoutException after 1000 ms
        return future.get(1000, TimeUnit.MILLISECONDS);
    } catch (ExecutionException e) {
        throw new RuntimeException(e.getCause());
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new TimeoutException();
    }
}

Answer 4

There is no general timeout mechanism valid for arbitrary operations.

While... there is one... by using Thread.stop(Throwable). It works and it's thread safe, but your personal safety is in danger when the angry mob confronts you.

// realizable 
try
{
    setTimeout(1s);  // 1
    ... any code     // 2 
    cancelTimeout(); // 3
}
catch(TimeoutException te)
{
    // if (3) isn't executed within 1s after (1)
    // we'll get this exception
} 

Answer 5

I recommend TimeLimiter from Google Guava library.

Answer 6

You could use a Timer and a TimerTask.